@vellumai/assistant 0.8.0 → 0.8.1

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

@@ -28,7 +28,6 @@ import { extname, isAbsolute, join, relative } from "node:path";
 
 import { getLogger } from "../../../util/logger.js";
 import { embedWithRetry } from "../../embed.js";
-import { generateSparseEmbedding } from "../../embedding-backend.js";
 import { spreadActivation } from "../../v2/activation.js";
 import { getEdgeIndex } from "../../v2/edge-index.js";
 import {
@@ -37,7 +36,8 @@ import {
   slugFromConceptPath,
 } from "../../v2/page-store.js";
 import { hybridQueryConceptPages } from "../../v2/qdrant.js";
-import { clampUnitInterval } from "../../validation.js";
+import { fuseHalf } from "../../v2/sim.js";
+import { generateBm25QueryEmbedding } from "../../v2/sparse-bm25.js";
 import type {
   RecallEvidence,
   RecallSearchContext,
@@ -173,7 +173,7 @@ async function activationEvidence(
   });
   const denseVector = denseResult.vectors[0];
   if (!denseVector || denseVector.length === 0) return [];
-  const sparseVector = generateSparseEmbedding(trimmedQuery);
+  const sparseVector = generateBm25QueryEmbedding(trimmedQuery);
 
   const annLimit =
     context.config.memory.v2.ann_candidate_limit ??
@@ -188,24 +188,43 @@ async function activationEvidence(
   const { dense_weight: denseWeight, sparse_weight: sparseWeight } =
     context.config.memory.v2;
 
-  let maxSparse = 0;
+  // Mirror sim.ts: normalize body and summary sparse channels against their
+  // own per-batch maxima, fuse each half via clamp01(dense·w_d + sparse·w_s),
+  // then take max(body, summary) per slug. Pages without a summary embedding
+  // return undefined for both summary scores; the max collapses cleanly to
+  // the body score so legacy pages keep their pre-summary ranking.
+  let maxBodySparse = 0;
+  let maxSummarySparse = 0;
   for (const hit of hits) {
-    if (hit.sparseScore !== undefined && hit.sparseScore > maxSparse) {
-      maxSparse = hit.sparseScore;
+    if (hit.sparseScore !== undefined && hit.sparseScore > maxBodySparse) {
+      maxBodySparse = hit.sparseScore;
+    }
+    if (
+      hit.summarySparseScore !== undefined &&
+      hit.summarySparseScore > maxSummarySparse
+    ) {
+      maxSummarySparse = hit.summarySparseScore;
     }
   }
 
   const ownActivation = new Map<string, number>();
   for (const hit of hits) {
-    const dense = hit.denseScore ?? 0;
-    const sparseNormalized =
-      hit.sparseScore !== undefined && maxSparse > 0
-        ? hit.sparseScore / maxSparse
-        : 0;
-    ownActivation.set(
-      hit.slug,
-      clampUnitInterval(denseWeight * dense + sparseWeight * sparseNormalized),
+    const bodyScore = fuseHalf(
+      hit.denseScore,
+      hit.sparseScore,
+      maxBodySparse,
+      denseWeight,
+      sparseWeight,
+    );
+    const summaryScore = fuseHalf(
+      hit.summaryDenseScore,
+      hit.summarySparseScore,
+      maxSummarySparse,
+      denseWeight,
+      sparseWeight,
     );
+    const score = Math.max(bodyScore ?? 0, summaryScore ?? bodyScore ?? 0);
+    ownActivation.set(hit.slug, score);
   }
 
   const edgeIndex = await getEdgeIndex(context.workingDir);
@@ -295,11 +314,13 @@ async function lexicalEvidence(
   if (!conceptsRoot) return [];
 
   const matches: MemoryV2LexicalMatch[] = [];
+  const visitedDirectories = new Set<string>([conceptsRoot]);
   await walkConceptsDirectory(
     conceptsRoot,
     conceptsRoot,
     queryTerms,
     matches,
+    visitedDirectories,
     context.signal,
   );
 
@@ -330,6 +351,7 @@ async function walkConceptsDirectory(
   conceptsRoot: string,
   queryTerms: ReadonlySet<string>,
   matches: MemoryV2LexicalMatch[],
+  visitedDirectories: Set<string>,
   signal: AbortSignal | undefined,
 ): Promise<void> {
   throwIfAborted(signal);
@@ -364,11 +386,14 @@ async function walkConceptsDirectory(
     }
 
     if (entryStats.isDirectory()) {
+      if (visitedDirectories.has(entryRealPath)) continue;
+      visitedDirectories.add(entryRealPath);
       await walkConceptsDirectory(
         entryRealPath,
         conceptsRoot,
         queryTerms,
         matches,
+        visitedDirectories,
         signal,
       );
       continue;

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

@@ -34,6 +34,7 @@ export async function searchMemorySource(
     });
     queryVector = result.vectors[0] ?? null;
   } catch (err) {
+    if (context.signal?.aborted || isAbortError(err)) throw err;
     log.warn({ err }, "Failed to embed memory recall query");
     return { evidence: [] };
   }
@@ -67,11 +68,17 @@ export async function searchMemorySource(
 
     return { evidence };
   } catch (err) {
+    if (context.signal?.aborted || isAbortError(err)) throw err;
     log.warn({ err }, "Failed to search memory graph for recall");
     return { evidence: [] };
   }
 }
 
+function isAbortError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  return err.name === "AbortError" || err.name === "APIUserAbortError";
+}
+
 function memoryNodeToEvidence(node: MemoryNode, score: number): RecallEvidence {
   return {
     id: `memory:${node.id}`,

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

@@ -23,7 +23,6 @@ const PATH_LITERAL_PATTERN =
 
 const WORKSPACE_BUCKETS: readonly WorkspaceBucket[] = [
   { name: "root", relativePath: "", budget: 100, rootFilesOnly: true },
-  { name: "pkb", relativePath: "pkb", budget: 500 },
   { name: "memory", relativePath: "memory", budget: 500 },
   { name: "journal", relativePath: "journal", budget: 250 },
   { name: "scratch", relativePath: "scratch", budget: 500 },
@@ -66,6 +65,9 @@ const SECRET_SEGMENT_NAMES = new Set([
   "ces-security",
 ]);
 
+const SECRET_TOKEN_PATTERN =
+  /(?:^|[-_.])(?:keys?|secrets?|tokens?)(?:[-_.]|$)/i;
+
 const QUERY_STOP_WORDS = new Set([
   "a",
   "about",
@@ -591,8 +593,13 @@ async function maybeSearchResolvedFile(
   matches: WorkspaceMatch[],
   state: WalkState,
 ): Promise<void> {
+  if (state.scannedRelativePaths.has(relativePath)) {
+    return;
+  }
+  state.scannedRelativePaths.add(relativePath);
+  state.scannedFiles += 1;
+
   if (
-    state.scannedRelativePaths.has(relativePath) ||
     shouldSkipWorkspaceFile(relativePath) ||
     shouldSkipFilePath(relativePath) ||
     fileSizeBytes > WORKSPACE_SOURCE_MAX_FILE_SIZE_BYTES
@@ -600,8 +607,6 @@ async function maybeSearchResolvedFile(
     return;
   }
 
-  state.scannedRelativePaths.add(relativePath);
-  state.scannedFiles += 1;
   matches.push(
     ...(await searchFile(realPath, relativePath, fileSizeBytes, queryTerms)),
   );
@@ -1049,8 +1054,6 @@ function getPathPriorityBoost(relativePath: string): number {
   if (relativePath.startsWith("scratch/")) return 0.35;
   if (relativePath.startsWith("users/")) return 0.3;
   if (relativePath.startsWith("journal/")) return 0.25;
-  if (relativePath.startsWith("pkb/archive/")) return -0.15;
-  if (relativePath.startsWith("pkb/")) return 0.2;
   if (relativePath.startsWith("memory/concepts/")) return 0.4;
   if (relativePath.startsWith("memory/")) return 0.2;
   if (
@@ -1181,15 +1184,15 @@ function shouldSkipSegmentName(name: string): boolean {
   return (
     GENERATED_OR_DEPENDENCY_DIR_NAMES.has(lowerName) ||
     lowerName.startsWith(".env") ||
-    lowerName.includes("key") ||
-    lowerName.includes("secret") ||
-    lowerName.includes("token") ||
+    SECRET_TOKEN_PATTERN.test(lowerName) ||
     lowerName.startsWith("credentials") ||
     SECRET_SEGMENT_NAMES.has(lowerName)
   );
 }
 
-function normalizeWorkspacePathLiteral(pathLiteral: string): string | null {
+export function normalizeWorkspacePathLiteral(
+  pathLiteral: string,
+): string | null {
   const trimmed = pathLiteral
     .trim()
     .replace(/^["'`]+|["'`.,;:)>\]}]+$/g, "")

package/src/memory/context-search/types.ts

@@ -1,6 +1,6 @@
 import type { AssistantConfig } from "../../config/schema.js";
 
-export type RecallSource = "memory" | "pkb" | "conversations" | "workspace";
+export type RecallSource = "memory" | "conversations" | "workspace";
 
 export type RecallDepth = "fast" | "standard" | "deep";
 

package/src/memory/conversation-bootstrap.ts

@@ -12,6 +12,14 @@ export interface BootstrapConversationOptions {
   systemHint: string;
   scheduleJobId?: string;
   groupId?: string;
+  /**
+   * When set, the new conversation is linked to its parent via the
+   * `fork_parent_conversation_id` column. Used by background jobs that
+   * spawn analysis conversations off a source conversation (auto-analyze,
+   * memory-retrospective) so the parent → child relationship is queryable
+   * later (e.g. "find the most recent retrospective for this source").
+   */
+  forkParentConversationId?: string;
 }
 
 export function bootstrapConversation(opts: BootstrapConversationOptions) {
@@ -21,6 +29,9 @@ export function bootstrapConversation(opts: BootstrapConversationOptions) {
     ...(opts.source && { source: opts.source }),
     ...(opts.scheduleJobId && { scheduleJobId: opts.scheduleJobId }),
     ...(opts.groupId && { groupId: opts.groupId }),
+    ...(opts.forkParentConversationId && {
+      forkParentConversationId: opts.forkParentConversationId,
+    }),
   });
   queueGenerateConversationTitle({
     conversationId: conversation.id,

package/src/memory/conversation-crud.ts

@@ -9,6 +9,7 @@ import {
   gt,
   gte,
   inArray,
+  isNotNull,
   isNull,
   like,
   lt,
@@ -45,8 +46,11 @@ import {
 } from "./conversation-disk-view.js";
 import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
 import { ensureGroupMigration } from "./conversation-group-migration.js";
-import { getDb } from "./db-connection.js";
+import { getDb, getSqliteFrom } from "./db-connection.js";
+import { forkGraphMemoryState } from "./graph/graph-memory-state-store.js";
 import { indexMessageNow } from "./indexer.js";
+import { MEMORY_RETROSPECTIVE_SOURCE } from "./memory-retrospective-constants.js";
+import { forkRetrospectiveState } from "./memory-retrospective-state.js";
 import { rawExec, rawGet, rawRun } from "./raw-query.js";
 import {
   channelInboundEvents,
@@ -60,6 +64,7 @@ import {
   toolInvocations,
 } from "./schema.js";
 import { cancelPendingJobsForConversation } from "./task-memory-cleanup.js";
+import { forkActivationState } from "./v2/activation-store.js";
 
 const log = getLogger("conversation-store");
 
@@ -112,6 +117,7 @@ export const messageMetadataSchema = z
     workspaceBlock: z.string().optional(),
     nowScratchpadBlock: z.string().optional(),
     pkbContextBlock: z.string().optional(),
+    memoryV2StaticBlock: z.string().optional(),
   })
   .passthrough();
 
@@ -186,6 +192,8 @@ export interface ConversationRow {
   lastMessageAt: number | null;
   archivedAt: number | null;
   inferenceProfile: string | null;
+  inferenceProfileSessionId: string | null;
+  inferenceProfileExpiresAt: number | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -216,6 +224,8 @@ export const parseConversation = createRowMapper<
   lastMessageAt: "lastMessageAt",
   archivedAt: "archivedAt",
   inferenceProfile: "inferenceProfile",
+  inferenceProfileSessionId: "inferenceProfileSessionId",
+  inferenceProfileExpiresAt: "inferenceProfileExpiresAt",
 });
 
 export interface MessageRow {
@@ -427,6 +437,60 @@ export function findAnalysisConversationFor(
   return row ? { id: row.id } : null;
 }
 
+/**
+ * Find the most recent memory-retrospective background conversation rooted
+ * at `parentConversationId`. Used by the memory-retrospective job handler
+ * to load the prior retrospective's `remember` calls into the new run's
+ * `<already_remembered>` block — bounded source-of-truth for "what the
+ * prior pass already saved" that scales as the source conversation grows.
+ *
+ * Walks up `forkParentConversationId` when no retrospective exists at the
+ * current level. This lets a forked conversation inherit dedup context from
+ * its source's most recent retro on the fork's *first* retrospective —
+ * otherwise the fork would re-save every fact the source already retro'd.
+ * Once the fork accumulates its own retros, those are found at the first
+ * iteration and we never walk up.
+ *
+ * Returns `null` when no prior retrospective exists anywhere in the fork
+ * chain (true first-run case).
+ *
+ * Hits `idx_conversations_fork_parent_conversation_id` for the
+ * `forkParentConversationId` lookup.
+ */
+const MAX_FORK_CHAIN_DEPTH = 16;
+
+export function findMostRecentRetrospectiveFor(
+  parentConversationId: string,
+): { id: string } | null {
+  const db = getDb();
+  let currentId: string | null = parentConversationId;
+  for (let depth = 0; depth < MAX_FORK_CHAIN_DEPTH && currentId; depth++) {
+    const row = db
+      .select({ id: conversations.id })
+      .from(conversations)
+      .where(
+        and(
+          eq(conversations.source, MEMORY_RETROSPECTIVE_SOURCE),
+          eq(conversations.forkParentConversationId, currentId),
+        ),
+      )
+      .orderBy(desc(conversations.createdAt))
+      .limit(1)
+      .get();
+    if (row) return { id: row.id };
+
+    const parent = db
+      .select({
+        forkParentConversationId: conversations.forkParentConversationId,
+      })
+      .from(conversations)
+      .where(eq(conversations.id, currentId))
+      .get();
+    currentId = parent?.forkParentConversationId ?? null;
+  }
+  return null;
+}
+
 /**
  * Returns the `source` column for the given conversation, or null if
  * not found. Tiny convenience used by the recursion guard in the
@@ -661,6 +725,19 @@ export function forkConversation(params: {
       latestAssistantMessageAt: latestForkedAssistant?.messageAt ?? null,
     });
 
+    // Carry the parent's per-conversation memory state into the child so the
+    // forked thread resumes with the same activation/injection log and
+    // in-context tracker the parent had at fork time.
+    forkActivationState(db, sourceConversation.id, fc.id);
+    forkGraphMemoryState(sourceConversation.id, fc.id);
+    forkRetrospectiveState({
+      database: db,
+      sourceConversationId: sourceConversation.id,
+      forkedConversationId: fc.id,
+      forkedMessageIds,
+      lastCopiedSourceMessageId: messagesToCopy.at(-1)?.id ?? null,
+    });
+
     return fc;
   });
 
@@ -1003,6 +1080,90 @@ export function selectSlackMetaCandidateMetadata(
   return out;
 }
 
+/**
+ * Count messages in a conversation that were created strictly after the
+ * `afterMessageId` reference message. If `afterMessageId` is `null` or empty,
+ * counts all messages in the conversation. If the referenced message no
+ * longer exists (e.g. deleted by a separate flow), returns 0 — callers
+ * decide how to react to a vanished reference, and the conservative answer
+ * here is "no new work."
+ *
+ * Used by the memory-retrospective trigger check to decide whether to fire
+ * the message-count trigger without loading message bodies.
+ */
+export function countMessagesAfter(
+  conversationId: string,
+  afterMessageId: string | null,
+): number {
+  const db = getDb();
+  if (afterMessageId === null || afterMessageId === "") {
+    const row = db
+      .select({ c: count() })
+      .from(messages)
+      .where(eq(messages.conversationId, conversationId))
+      .get();
+    return row?.c ?? 0;
+  }
+  const ref = db
+    .select({ createdAt: messages.createdAt })
+    .from(messages)
+    .where(eq(messages.id, afterMessageId))
+    .get();
+  if (!ref) return 0;
+  const row = db
+    .select({ c: count() })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, conversationId),
+        gt(messages.createdAt, ref.createdAt),
+      ),
+    )
+    .get();
+  return row?.c ?? 0;
+}
+
+/**
+ * Return messages in a conversation created strictly after the
+ * `afterMessageId` reference. If the reference is `null`/empty, returns all
+ * messages. If the reference doesn't exist, returns an empty array (mirrors
+ * `countMessagesAfter`'s conservative semantics). Used by the
+ * memory-retrospective job handler to load the message slice it processes.
+ */
+export function getMessagesAfter(
+  conversationId: string,
+  afterMessageId: string | null,
+): MessageRow[] {
+  const db = getDb();
+  if (afterMessageId === null || afterMessageId === "") {
+    return db
+      .select()
+      .from(messages)
+      .where(eq(messages.conversationId, conversationId))
+      .orderBy(asc(messages.createdAt))
+      .all()
+      .map(parseMessage);
+  }
+  const ref = db
+    .select({ createdAt: messages.createdAt })
+    .from(messages)
+    .where(eq(messages.id, afterMessageId))
+    .get();
+  if (!ref) return [];
+  return db
+    .select()
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, conversationId),
+        gt(messages.createdAt, ref.createdAt),
+      ),
+    )
+    .orderBy(asc(messages.createdAt))
+    .all()
+    .map(parseMessage);
+}
+
 /**
  * Efficient existence check — returns true if the conversation has at least
  * one message row. Uses `LIMIT 1` + `select({ 1 })` to avoid loading and
@@ -1226,6 +1387,10 @@ export function unarchiveConversation(id: string): boolean {
  * Set or clear the inference profile override for a conversation.
  * Pass `null` to clear the override and fall back to the workspace
  * `llm.activeProfile` resolution.
+ *
+ * Also clears any stale session columns (`inferenceProfileSessionId`,
+ * `inferenceProfileExpiresAt`) so that the reaper and lazy expiry check
+ * cannot later clobber the newly-set profile.
  */
 export function setConversationInferenceProfile(
   conversationId: string,
@@ -1233,17 +1398,130 @@ export function setConversationInferenceProfile(
 ): void {
   const db = getDb();
   db.update(conversations)
-    .set({ inferenceProfile: profile, updatedAt: Date.now() })
+    .set({
+      inferenceProfile: profile,
+      inferenceProfileSessionId: null,
+      inferenceProfileExpiresAt: null,
+      updatedAt: Date.now(),
+    })
+    .where(eq(conversations.id, conversationId))
+    .run();
+}
+
+/**
+ * Atomically set the inference profile, session id, and expiry timestamp for
+ * a conversation. Pass `null` for all three to clear the session-backed
+ * override and fall back to the workspace `llm.activeProfile` resolution.
+ */
+export function setConversationInferenceProfileSession(
+  conversationId: string,
+  profile: string | null,
+  sessionId: string | null,
+  expiresAt: number | null,
+): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({
+      inferenceProfile: profile,
+      inferenceProfileSessionId: sessionId,
+      inferenceProfileExpiresAt: expiresAt,
+      updatedAt: Date.now(),
+    })
     .where(eq(conversations.id, conversationId))
     .run();
 }
 
+/**
+ * Clear all conversations whose session-backed inference profile has expired.
+ * Returns an array of `{ conversationId, sessionId }` for each cleared row so
+ * callers can emit the appropriate update events.
+ */
+export function clearExpiredInferenceProfiles(
+  now: number,
+): Array<{ conversationId: string; sessionId: string | null }> {
+  const raw = getSqliteFrom(getDb());
+  // Two-step approach: SELECT to get pre-clear sessionIds, then UPDATE.
+  // The UPDATE re-applies the WHERE condition for CAS safety.
+  // RETURNING the id lets us know which rows were actually cleared.
+  const expired = raw
+    .prepare(
+      `
+    SELECT id AS conversationId, inference_profile_session_id AS sessionId
+    FROM conversations
+    WHERE inference_profile_expires_at IS NOT NULL AND inference_profile_expires_at <= ?
+  `,
+    )
+    .all(now) as Array<{ conversationId: string; sessionId: string | null }>;
+
+  if (expired.length === 0) return [];
+
+  const ids = expired.map((r) => r.conversationId);
+  const placeholders = ids.map(() => "?").join(", ");
+
+  const actuallyCleared = raw
+    .prepare(
+      `
+    UPDATE conversations
+    SET inference_profile = NULL, inference_profile_session_id = NULL, inference_profile_expires_at = NULL
+    WHERE id IN (${placeholders}) AND inference_profile_expires_at IS NOT NULL AND inference_profile_expires_at <= ?
+    RETURNING id AS conversationId
+  `,
+    )
+    .all(...ids, now) as Array<{ conversationId: string }>;
+
+  const clearedSet = new Set(actuallyCleared.map((r) => r.conversationId));
+  return expired.filter((r) => clearedSet.has(r.conversationId));
+}
+
+/**
+ * List conversations with an active (non-expired) session-backed inference
+ * profile. Pass a `conversationId` to narrow to a single conversation.
+ */
+export function listActiveInferenceProfileSessions(
+  conversationId?: string,
+): Array<{
+  conversationId: string;
+  conversationTitle: string | null;
+  profile: string;
+  sessionId: string;
+  expiresAt: number;
+}> {
+  const db = getDb();
+  const now = Date.now();
+  const baseConditions = [
+    isNotNull(conversations.inferenceProfile),
+    isNotNull(conversations.inferenceProfileExpiresAt),
+    gt(conversations.inferenceProfileExpiresAt, now),
+    isNotNull(conversations.inferenceProfileSessionId),
+  ];
+  if (conversationId) {
+    baseConditions.push(eq(conversations.id, conversationId));
+  }
+  return db
+    .select({
+      conversationId: conversations.id,
+      conversationTitle: conversations.title,
+      profile: conversations.inferenceProfile,
+      sessionId: conversations.inferenceProfileSessionId,
+      expiresAt: conversations.inferenceProfileExpiresAt,
+    })
+    .from(conversations)
+    .where(and(...baseConditions))
+    .all() as Array<{
+    conversationId: string;
+    conversationTitle: string | null;
+    profile: string;
+    sessionId: string;
+    expiresAt: number;
+  }>;
+}
+
 /**
  * Resolve the per-turn inference-profile override from an already-loaded
- * conversation row. Returns the row's `inferenceProfile` for non-background
- * conversations, `undefined` otherwise — background turns (subagent fan-out,
- * scheduled tasks, update bulletins) run on the workspace defaults rather
- * than inheriting an interactive override.
+ * conversation row. Returns the row's `inferenceProfile` for interactive
+ * conversations, `undefined` for automation threads (subagent fan-out,
+ * scheduled tasks, update bulletins) so they run on the workspace defaults
+ * rather than inheriting an interactive override.
  *
  * Prefer this row-based form when the caller already needs to read the
  * conversation row for other reasons (e.g. the agent loop's title check).
@@ -1251,7 +1529,27 @@ export function setConversationInferenceProfile(
 export function getConversationOverrideProfileFromRow(
   conv: ConversationRow | null,
 ): string | undefined {
-  if (conv?.conversationType === "background") return undefined;
+  if (
+    conv?.conversationType === "background" ||
+    conv?.conversationType === "scheduled"
+  ) {
+    return undefined;
+  }
+  // Treat an expired session as if the override is absent. The eager reaper
+  // clears the row and emits the update event; the lazy check here ensures
+  // correctness on read paths before the reaper fires.
+  //
+  // `<=` (not `<`) for boundary consistency with the rest of the session
+  // logic: the reaper SQL uses `expires_at <= ?`, and the active-session
+  // queries use `expiresAt > now` (i.e. treat exact-expiry as inactive).
+  // Without this, a session at the exact-expiry millisecond would be served
+  // for one extra turn here while being cleared by the reaper.
+  if (
+    conv?.inferenceProfileExpiresAt != null &&
+    conv.inferenceProfileExpiresAt <= Date.now()
+  ) {
+    return undefined;
+  }
   return conv?.inferenceProfile ?? undefined;
 }
 
@@ -1481,8 +1779,10 @@ export function updateMessageMetadata(
 /**
  * Bulk-remove the metadata fields that back the blocks stripped by
  * `stripInjectionsForCompaction` — currently `pkbSystemReminderBlock`
- * (`<system_reminder>`), `nowScratchpadBlock` (`<NOW.md …>`), and
- * `pkbContextBlock` (`<knowledge_base>`). Called from compaction-strip
+ * (`<system_reminder>`), `nowScratchpadBlock` (`<NOW.md …>`),
+ * `pkbContextBlock` (`<knowledge_base>`), and `memoryV2StaticBlock`
+ * (the static `<memory>\n…</memory>` block matched by the `<memory>\n`
+ * prefix in `RUNTIME_INJECTION_PREFIXES`). Called from compaction-strip
  * sites so post-restart rehydration stays consistent with the in-memory
  * state produced by `stripInjectionsForCompaction` (which removes those
  * tags from live messages but cannot touch the DB). Fields backing
@@ -1498,7 +1798,8 @@ export function clearStrippedInjectionMetadataForConversation(
           metadata,
           '$.pkbSystemReminderBlock',
           '$.nowScratchpadBlock',
-          '$.pkbContextBlock'
+          '$.pkbContextBlock',
+          '$.memoryV2StaticBlock'
         )
       WHERE conversation_id = ?
         AND role = 'user'
@@ -1507,6 +1808,7 @@ export function clearStrippedInjectionMetadataForConversation(
           json_extract(metadata, '$.pkbSystemReminderBlock') IS NOT NULL
           OR json_extract(metadata, '$.nowScratchpadBlock') IS NOT NULL
           OR json_extract(metadata, '$.pkbContextBlock') IS NOT NULL
+          OR json_extract(metadata, '$.memoryV2StaticBlock') IS NOT NULL
         )`,
     conversationId,
   );