@vellumai/assistant 0.7.0 → 0.7.2

package/src/memory/conversation-crud.ts

@@ -32,7 +32,7 @@ import {
   deleteOrphanAttachments,
   linkAttachmentToMessage,
 } from "./attachments-store.js";
-import { AUTO_ANALYSIS_SOURCE } from "./auto-analysis-guard.js";
+import { AUTO_ANALYSIS_SOURCE } from "./auto-analysis-constants.js";
 import {
   projectAssistantMessage,
   seedForkedConversationAttention,
@@ -174,6 +174,8 @@ export interface ConversationRow {
   contextSummary: string | null;
   contextCompactedMessageCount: number;
   contextCompactedAt: number | null;
+  slackContextCompactionWatermarkTs: string | null;
+  slackContextCompactionWatermarkAt: number | null;
   conversationType: string;
   source: string;
   memoryScopeId: string;
@@ -202,6 +204,8 @@ export const parseConversation = createRowMapper<
   contextSummary: "contextSummary",
   contextCompactedMessageCount: "contextCompactedMessageCount",
   contextCompactedAt: "contextCompactedAt",
+  slackContextCompactionWatermarkTs: "slackContextCompactionWatermarkTs",
+  slackContextCompactionWatermarkAt: "slackContextCompactionWatermarkAt",
   conversationType: "conversationType",
   source: "source",
   memoryScopeId: "memoryScopeId",
@@ -225,10 +229,7 @@ export interface MessageRow {
   metadata: string | null;
 }
 
-const parseMessage = createRowMapper<
-  typeof messages.$inferSelect,
-  MessageRow
->({
+const parseMessage = createRowMapper<typeof messages.$inferSelect, MessageRow>({
   id: "id",
   conversationId: "conversationId",
   role: "role",
@@ -295,6 +296,8 @@ export function createConversation(
     contextSummary: null as string | null,
     contextCompactedMessageCount: 0,
     contextCompactedAt: null as number | null,
+    slackContextCompactionWatermarkTs: null as string | null,
+    slackContextCompactionWatermarkAt: null as number | null,
     conversationType,
     source,
     memoryScopeId,
@@ -542,6 +545,12 @@ export function forkConversation(params: {
         contextCompactedAt: preserveSourceCompactionState
           ? sourceConversation.contextCompactedAt
           : null,
+        slackContextCompactionWatermarkTs: preserveSourceCompactionState
+          ? sourceConversation.slackContextCompactionWatermarkTs
+          : null,
+        slackContextCompactionWatermarkAt: preserveSourceCompactionState
+          ? sourceConversation.slackContextCompactionWatermarkAt
+          : null,
         inferenceProfile: sourceConversation.inferenceProfile,
       })
       .where(eq(conversations.id, fc.id))
@@ -1180,6 +1189,22 @@ export function updateConversationContextWindow(
     .run();
 }
 
+export function updateConversationSlackContextWatermark(
+  id: string,
+  watermarkTs: string,
+  compactedAt: number = Date.now(),
+): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({
+      slackContextCompactionWatermarkTs: watermarkTs,
+      slackContextCompactionWatermarkAt: compactedAt,
+      updatedAt: Date.now(),
+    })
+    .where(eq(conversations.id, id))
+    .run();
+}
+
 export function archiveConversation(id: string): boolean {
   const conv = getConversation(id);
   if (!conv) return false;

package/src/memory/conversation-disk-view.ts

@@ -43,11 +43,7 @@ const log = getLogger("conversation-disk-view");
 // Directory helpers
 // ---------------------------------------------------------------------------
 
-export {
-  getConversationDirName,
-  getConversationDirPath,
-  getResolvedConversationDirPath,
-};
+export { getConversationDirName, getConversationDirPath };
 
 function ensureConversationDirPath(id: string, createdAtMs: number): string {
   const dirPath = getResolvedConversationDirPath(id, createdAtMs);

package/src/memory/conversation-key-store.ts

@@ -7,20 +7,15 @@
  * first contact.
  */
 
-import { existsSync, unlinkSync } from "node:fs";
-
 import { eq } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getLogger } from "../util/logger.js";
-import { getWorkspacePromptPath } from "../util/platform.js";
+import { cleanupBootstrapFiles } from "../prompts/bootstrap-cleanup.js";
 import { initConversationDir } from "./conversation-disk-view.js";
 import { GENERATING_TITLE } from "./conversation-title-service.js";
 import { getDb } from "./db-connection.js";
 import { conversationKeys, conversations } from "./schema.js";
 
-const log = getLogger("conversation-key-store");
-
 /** Set after the first conversation is created so BOOTSTRAP.md is deleted on the second. */
 let firstConversationSeen = false;
 
@@ -204,15 +199,7 @@ export function getOrCreateConversation(
     // for its entire duration. Any subsequent conversation means
     // onboarding is over.
     if (firstConversationSeen) {
-      const bp = getWorkspacePromptPath("BOOTSTRAP.md");
-      if (existsSync(bp)) {
-        try {
-          unlinkSync(bp);
-          log.info("Deleted BOOTSTRAP.md — onboarding conversation ended");
-        } catch {
-          // Best-effort
-        }
-      }
+      cleanupBootstrapFiles("new conversation created after onboarding");
     }
     firstConversationSeen = true;
 

package/src/memory/conversation-starter-checkpoints.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared checkpoint helpers for conversation starters.
+ *
+ * Used by both the job handler (generation) and the route handler (refresh decisions).
+ */
+
+import { eq } from "drizzle-orm";
+
+import { getDb } from "./db-connection.js";
+import { rawGet } from "./raw-query.js";
+import { memoryCheckpoints } from "./schema.js";
+
+// ── Checkpoint keys ──────────────────────────────────────────────
+
+export const CK_ITEM_COUNT = "conversation_starters:item_count_at_last_gen";
+export const CK_BATCH = "conversation_starters:generation_batch";
+export const CK_LAST_GEN_AT = "conversation_starters:last_gen_at";
+
+export function checkpointKey(base: string, scopeId: string): string {
+  return `${base}:${scopeId}`;
+}
+
+export function parseCheckpointInt(value: string | undefined): number | null {
+  if (value == null) return null;
+  const n = parseInt(value, 10);
+  return Number.isNaN(n) ? null : n;
+}
+
+export function getCheckpointValue(key: string): string | undefined {
+  return getDb()
+    .select({ value: memoryCheckpoints.value })
+    .from(memoryCheckpoints)
+    .where(eq(memoryCheckpoints.key, key))
+    .get()?.value;
+}
+
+// ── Writes ───────────────────────────────────────────────────────
+
+export function upsertCheckpoint(
+  key: string,
+  value: string,
+  now: number = Date.now(),
+): void {
+  getDb()
+    .insert(memoryCheckpoints)
+    .values({ key, value, updatedAt: now })
+    .onConflictDoUpdate({
+      target: memoryCheckpoints.key,
+      set: { value, updatedAt: now },
+    })
+    .run();
+}
+
+// ── Queries ──────────────────────────────────────────────────────
+
+export function countActiveMemoryNodes(scopeId: string): number {
+  return (
+    rawGet<{ c: number }>(
+      `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
+      scopeId,
+    )?.c ?? 0
+  );
+}

package/src/memory/db-connection.ts

@@ -1,3 +1,6 @@
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve, sep } from "node:path";
 import { Database } from "bun:sqlite";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
@@ -9,8 +12,67 @@ export type DrizzleDb = ReturnType<typeof drizzle<typeof schema>>;
 
 let db: DrizzleDb | null = null;
 
+function canonicalizePathThroughExistingParent(path: string): string {
+  const resolvedPath = resolve(path);
+  const pendingSegments: string[] = [];
+  let currentPath = resolvedPath;
+
+  while (true) {
+    try {
+      return resolve(realpathSync(currentPath), ...pendingSegments.reverse());
+    } catch {
+      const parentPath = dirname(currentPath);
+      if (parentPath === currentPath) {
+        return resolvedPath;
+      }
+      pendingSegments.push(basename(currentPath));
+      currentPath = parentPath;
+    }
+  }
+}
+
+function assertTestDbIsIsolated(): void {
+  if (
+    process.env.NODE_ENV !== "test" ||
+    process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS === "1"
+  ) {
+    return;
+  }
+
+  const workspaceDir = process.env.VELLUM_WORKSPACE_DIR?.trim();
+  if (!workspaceDir) {
+    throw new Error(
+      [
+        "Refusing to open the assistant DB during tests without VELLUM_WORKSPACE_DIR.",
+        "Run assistant tests from the assistant package so the test preload can isolate state:",
+        "  cd assistant && bun test src/path/to/file.test.ts",
+      ].join("\n"),
+    );
+  }
+
+  const resolvedWorkspaceDir =
+    canonicalizePathThroughExistingParent(workspaceDir);
+  const realWorkspaceDir = canonicalizePathThroughExistingParent(
+    process.env.VELLUM_TEST_REAL_WORKSPACE_DIR?.trim() ||
+      join(homedir(), ".vellum", "workspace"),
+  );
+  if (
+    resolvedWorkspaceDir === realWorkspaceDir ||
+    resolvedWorkspaceDir.startsWith(realWorkspaceDir + sep)
+  ) {
+    throw new Error(
+      [
+        "Refusing to open the real assistant workspace DB during tests.",
+        `VELLUM_WORKSPACE_DIR resolved to ${resolvedWorkspaceDir}.`,
+        "Use a temp workspace for tests instead.",
+      ].join("\n"),
+    );
+  }
+}
+
 export function getDb(): DrizzleDb {
   if (!db) {
+    assertTestDbIsIsolated();
     ensureDataDir();
     const sqlite = new Database(getDbPath());
     sqlite.exec("PRAGMA journal_mode=WAL");

package/src/memory/db-init.ts

@@ -11,6 +11,7 @@ import { dirname, join } from "node:path";
 
 import { getLogger } from "../util/logger.js";
 import { ensureDataDir, getDbPath } from "../util/platform.js";
+import { backfillAppConversationIds } from "./app-store.js";
 import { getDb, getSqlite } from "./db-connection.js";
 import { migrateToolCreatedItems } from "./graph/bootstrap.js";
 import {
@@ -66,6 +67,7 @@ import {
   migrateConversationsLastMessageAt,
   migrateConversationsThreadTypeIndex,
   migrateCreateConversationGraphMemoryState,
+  migrateCreateDocumentConversations,
   migrateCreateMemoryGraphNodeEdits,
   migrateCreateMemoryGraphTables,
   migrateCreateMemoryRecallLogs,
@@ -100,14 +102,17 @@ import {
   migrateGuardianTimestampsEpochMs,
   migrateGuardianVerificationPurpose,
   migrateGuardianVerificationSessions,
+  migrateHeartbeatRuns,
   migrateInviteCodeHashColumn,
   migrateInviteContactId,
   migrateLlmRequestLogMessageId,
   migrateLlmRequestLogProvider,
   migrateLlmRequestLogsCreatedAtIndex,
+  migrateLlmUsageAttribution,
   migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
   migrateMemoryRecallLogsQueryContext,
+  migrateMemoryV2ActivationLogs,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
   migrateNormalizePhoneIdentities,
@@ -149,14 +154,17 @@ import {
   migrateRenameVoiceToPhone,
   migrateScheduleOneShotRouting,
   migrateScheduleQuietFlag,
+  migrateScheduleRetryPolicy,
   migrateScheduleReuseConversation,
   migrateScheduleScriptColumn,
   migrateScheduleWakeConversationId,
   migrateSchemaIndexesAndColumns,
   migrateScrubCorruptedImageAttachments,
+  migrateSlackCompactionWatermark,
   migrateStripIntegrationPrefixFromProviderKeys,
   migrateStripPlaceholderSentinelsFromMessages,
   migrateStripThinkingFromConsolidated,
+  migrateToolInvocationsMatchedRuleId,
   migrateUsageDashboardIndexes,
   migrateUsageLlmCallCount,
   migrateVoiceInviteColumns,
@@ -390,6 +398,16 @@ export function initializeDb(): void {
     migrate230AcpSessionHistory,
     migrate231RepairMemoryGraphEventDates,
     migrateActivationState,
+    migrateMemoryV2ActivationLogs,
+    migrateCreateDocumentConversations,
+    migrateLlmUsageAttribution,
+    migrateSlackCompactionWatermark,
+    migrateToolInvocationsMatchedRuleId,
+    migrateHeartbeatRuns,
+    function migrateBackfillAppConversationIds() {
+      backfillAppConversationIds();
+    },
+    migrateScheduleRetryPolicy,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/embedding-backend.ts

@@ -11,16 +11,19 @@ import { GeminiEmbeddingBackend } from "./embedding-gemini.js";
 import { OllamaEmbeddingBackend } from "./embedding-ollama.js";
 import { OpenAIEmbeddingBackend } from "./embedding-openai.js";
 import {
+  type EmbeddingBackend,
   type EmbeddingInput,
   embeddingInputContentHash,
+  type EmbeddingProviderName,
+  type EmbeddingRequestOptions,
   type MultimodalEmbeddingInput,
   normalizeEmbeddingInput,
   type SparseEmbedding,
   type TextEmbeddingInput,
 } from "./embedding-types.js";
+import { SPARSE_VOCAB_SIZE, tokenHash, tokenize } from "./sparse-tokenize.js";
 
 export type { EmbeddingInput, MultimodalEmbeddingInput, TextEmbeddingInput };
-export { embeddingInputContentHash, normalizeEmbeddingInput };
 
 const log = getLogger("memory-embeddings");
 
@@ -263,22 +266,6 @@ function geminiCacheExtras(config: AssistantConfig): string[] {
   return extras;
 }
 
-export type EmbeddingProviderName = "local" | "openai" | "gemini" | "ollama";
-
-export interface EmbeddingRequestOptions {
-  signal?: AbortSignal;
-}
-
-export interface EmbeddingBackend {
-  readonly provider: EmbeddingProviderName;
-  readonly model: string;
-  embed(
-    inputs: EmbeddingInput[],
-    options?: EmbeddingRequestOptions,
-  ): Promise<number[][]>;
-  dispose?(): void;
-}
-
 export interface EmbeddingBackendSelection {
   backend: EmbeddingBackend | null;
   reason: string | null;
@@ -637,10 +624,6 @@ export async function embedWithBackend(
   throw lastErr;
 }
 
-export function logMemoryEmbeddingWarning(err: unknown, context: string): void {
-  log.warn({ err }, `Memory embeddings failed (${context})`);
-}
-
 async function selectFallbackBackends(
   config: AssistantConfig,
   exclude: EmbeddingProviderName,
@@ -805,31 +788,18 @@ async function isOllamaConfigured(config: AssistantConfig): Promise<boolean> {
 // Simple tokenizer + TF-IDF sparse encoder. Produces a SparseEmbedding
 // with term indices (hashed to a fixed vocabulary) and TF-IDF weights.
 // Can be upgraded to a learned sparse encoder (e.g. SPLADE) later.
-
-const SPARSE_VOCAB_SIZE = 30_000;
+// Tokenization primitives (`tokenize`, `tokenHash`, `SPARSE_VOCAB_SIZE`) live
+// in `./sparse-tokenize.ts` so the BM25 encoder can share them without
+// transitively depending on this module.
 
 /**
  * Bump this version whenever the sparse embedding algorithm changes
- * (e.g. hash function fix, tokenizer change) to trigger re-indexing
- * of existing sparse vectors via the sentinel mismatch mechanism.
+ * (e.g. hash function fix, tokenizer change). Now inert metadata — the v1
+ * Qdrant sentinel was decoupled from this constant, so a bump no longer
+ * forces an automatic rebuild. Operators must explicitly run
+ * `assistant memory v2 reembed` to rematerialize the v2 sparse index.
  */
-export const SPARSE_EMBEDDING_VERSION = 2;
-
-/** Tokenize text into lowercase alphanumeric tokens (Unicode-aware). */
-function tokenize(text: string): string[] {
-  return text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
-}
-
-/** Hash a token to a stable index in [0, vocabSize). */
-function tokenHash(token: string, vocabSize: number): number {
-  // FNV-1a 32-bit hash for speed
-  let hash = 0x811c9dc5;
-  for (let i = 0; i < token.length; i++) {
-    hash ^= token.charCodeAt(i);
-    hash = Math.imul(hash, 0x01000193) >>> 0;
-  }
-  return hash % vocabSize;
-}
+export const SPARSE_EMBEDDING_VERSION = 4;
 
 /**
  * Generate a TF-IDF-based sparse embedding for the given text.

package/src/memory/embedding-gemini.ts

@@ -2,8 +2,6 @@ import type {
   EmbeddingBackend,
   EmbeddingInput,
   EmbeddingRequestOptions,
-} from "./embedding-backend.js";
-import type {
   EmbeddingTaskType,
   MultimodalEmbeddingInput,
 } from "./embedding-types.js";

package/src/memory/embedding-local.ts

@@ -14,13 +14,13 @@ import {
   getEmbedWorkerPidPath,
 } from "../util/platform.js";
 import { PromiseGuard } from "../util/promise-guard.js";
-import type {
-  EmbeddingBackend,
-  EmbeddingInput,
-  EmbeddingRequestOptions,
-} from "./embedding-backend.js";
 import { EmbeddingRuntimeManager } from "./embedding-runtime-manager.js";
-import { normalizeEmbeddingInput } from "./embedding-types.js";
+import {
+  type EmbeddingBackend,
+  type EmbeddingInput,
+  type EmbeddingRequestOptions,
+  normalizeEmbeddingInput,
+} from "./embedding-types.js";
 
 const log = getLogger("memory-embedding-local");
 

package/src/memory/embedding-ollama.ts

@@ -1,10 +1,10 @@
 import { getOllamaBaseUrlEnv } from "../config/env.js";
-import type {
-  EmbeddingBackend,
-  EmbeddingInput,
-  EmbeddingRequestOptions,
-} from "./embedding-backend.js";
-import { normalizeEmbeddingInput } from "./embedding-types.js";
+import {
+  type EmbeddingBackend,
+  type EmbeddingInput,
+  type EmbeddingRequestOptions,
+  normalizeEmbeddingInput,
+} from "./embedding-types.js";
 
 interface OllamaEmbeddingsResponse {
   data?: Array<{ embedding: number[] }>;

package/src/memory/embedding-openai.ts

@@ -1,11 +1,11 @@
 import OpenAI from "openai";
 
-import type {
-  EmbeddingBackend,
-  EmbeddingInput,
-  EmbeddingRequestOptions,
-} from "./embedding-backend.js";
-import { normalizeEmbeddingInput } from "./embedding-types.js";
+import {
+  type EmbeddingBackend,
+  type EmbeddingInput,
+  type EmbeddingRequestOptions,
+  normalizeEmbeddingInput,
+} from "./embedding-types.js";
 
 export class OpenAIEmbeddingBackend implements EmbeddingBackend {
   readonly provider = "openai" as const;

package/src/memory/embedding-types.ts

@@ -67,3 +67,24 @@ export function embeddingInputContentHash(input: EmbeddingInput): string {
   }
   return hash.digest("hex");
 }
+
+// ---------------------------------------------------------------------------
+// Backend interface types (extracted from embedding-backend.ts to break
+// circular imports between the factory and provider implementations)
+// ---------------------------------------------------------------------------
+
+export type EmbeddingProviderName = "local" | "openai" | "gemini" | "ollama";
+
+export interface EmbeddingRequestOptions {
+  signal?: AbortSignal;
+}
+
+export interface EmbeddingBackend {
+  readonly provider: EmbeddingProviderName;
+  readonly model: string;
+  embed(
+    inputs: EmbeddingInput[],
+    options?: EmbeddingRequestOptions,
+  ): Promise<number[][]>;
+  dispose?(): void;
+}

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

@@ -140,10 +140,6 @@ beforeAll(() => {
   // 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.`,
@@ -337,16 +333,54 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
 
     expect(result.mode).toBe("per-turn");
     expect(result.injectedBlockText).not.toBeNull();
-    expect(result.injectedBlockText).toContain("<memory __injected>");
+    expect(result.injectedBlockText).not.toContain("<memory>");
     expect(result.injectedBlockText).toContain("### alice-vscode");
 
-    // The leading content block on the user message is the v2 block.
+    // The leading content block on the user message is the v2 block,
+    // wrapped exactly once.
     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>");
+    expect(firstBlock.text.startsWith("<memory>\n")).toBe(true);
+    expect(firstBlock.text.endsWith("\n</memory>")).toBe(true);
+    // No nested wrapper.
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
+  });
+
+  test("reinjectCachedMemory after v2 injection wraps exactly once (no double-wrap)", async () => {
+    // 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();
+    const config = makeConfig(true);
+    const messages = makeMessages("Tell me about Alice's editor preferences");
+
+    const initial = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+    expect(initial.injectedBlockText).not.toBeNull();
+
+    // Simulate post-compaction: caller re-runs `applyRuntimeInjections`
+    // (which strips memory injections) and then asks for the cached
+    // memory to be re-prepended.
+    const reinjected = memory.reinjectCachedMemory(messages);
+    const lastMsg = reinjected.runMessages[reinjected.runMessages.length - 1];
+    const firstBlock = lastMsg?.content[0];
+    expect(firstBlock?.type).toBe("text");
+    if (firstBlock?.type !== "text") throw new Error("unexpected block type");
+    expect(firstBlock.text.startsWith("<memory>\n")).toBe(true);
+    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");
   });
 
   test("flag on + config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
@@ -388,7 +422,14 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
 
     expect(result.mode).toBe("context-load");
     expect(result.injectedBlockText).not.toBeNull();
-    expect(result.injectedBlockText).toContain("<memory __injected>");
+    expect(result.injectedBlockText).toContain("### alice-vscode");
+    // injectedBlockText is the unwrapped inner content; the wrapper is
+    // applied at injection time on the run message.
+    expect(result.injectedBlockText).not.toContain("<memory>");
+    const lastMsg = result.runMessages[result.runMessages.length - 1];
+    const firstBlock = lastMsg?.content[0];
+    if (firstBlock?.type !== "text") throw new Error("unexpected block type");
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
   });
 
   test("flag off → v2 not run on first turn either", async () => {