@vellumai/assistant 0.8.5 → 0.8.6

package/src/home/suggested-prompts.ts

@@ -2,87 +2,25 @@
  * Suggested prompt producer for the Home feed.
  *
  * Returns an array of `SuggestedPrompt` items shown at the top of the
- * Home page as conversation starters (e.g. "Connect Gmail", "Add Slack").
- *
- * Two sources of prompts:
- *   - **Deterministic** — derived from missing OAuth connections.
- *     Computed inline (read-only, safe for GET).
- *   - **Assistant-generated** — contextual suggestions from the LLM
- *     based on what's relevant to the user. Read from an in-memory
- *     cache in the GET path; generation runs in the background via
- *     `refreshAssistantSuggestedPrompts`.
+ * Home page as conversation starters. All prompts are generated by the
+ * assistant based on the user's connected services and context —
+ * read from an in-memory cache in the GET path; generation runs in
+ * the background via `refreshAssistantSuggestedPrompts`.
  */
 
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
-import { listProviders } from "../oauth/oauth-store.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { getConfiguredProvider } from "../providers/provider-send-message.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { runBtwSidechain } from "../runtime/btw-sidechain.js";
-import { isOAuthProviderConnected } from "../schedule/integration-status.js";
+import { formatIntegrationSummary } from "../schedule/integration-status.js";
 import { getLogger } from "../util/logger.js";
 import type { SuggestedPrompt } from "./feed-types.js";
 
 const log = getLogger("suggested-prompts");
 
-/**
- * Map of provider keys to their suggested-prompt metadata. Only providers
- * listed here produce deterministic "Connect X" prompts when disconnected.
- * The icon values are VIcon case names rendered by the macOS client.
- */
-interface PromptEntry {
-  label: string;
-  prompt: string;
-  icon: string;
-}
-
-const CONNECT_PROMPT_META: Record<
-  string,
-  PromptEntry & { connectedPrompts?: PromptEntry[] }
-> = {
-  google: {
-    label: "Connect Gmail",
-    prompt: "Help me connect my Gmail account",
-    icon: "mail",
-    connectedPrompts: [
-      {
-        label: "Triage my inbox",
-        prompt:
-          "Help me triage my inbox — summarize what's unread and flag anything that needs a reply",
-        icon: "mail",
-      },
-      {
-        label: "Summarize today's emails",
-        prompt:
-          "Summarize the emails I received today and highlight anything important",
-        icon: "mail",
-      },
-    ],
-  },
-  slack: {
-    label: "Connect Slack",
-    prompt: "Help me connect my Slack workspace",
-    icon: "hash",
-  },
-  notion: {
-    label: "Connect Notion",
-    prompt: "Help me connect my Notion workspace",
-    icon: "fileText",
-  },
-  linear: {
-    label: "Connect Linear",
-    prompt: "Help me connect my Linear workspace",
-    icon: "clipboardList",
-  },
-  github: {
-    label: "Connect GitHub",
-    prompt: "Help me connect my GitHub account",
-    icon: "terminal",
-  },
-};
-
 const LLM_SUGGESTIONS_TIMEOUT_MS = 5_000;
 const LLM_CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes
 
@@ -94,37 +32,23 @@ let cachedLLMPrompts: SuggestedPrompt[] = [];
 let cachedLLMPromptsAt = 0;
 
 /**
- * Produce suggested prompts from both deterministic and cached LLM sources.
- * Deterministic prompts always come first; cached LLM-generated prompts are
- * appended when available. No LLM calls happen in this path — safe for GET.
+ * Return cached assistant-generated prompts. No LLM calls happen in
+ * this path — safe for GET. Returns an empty array until the first
+ * background refresh populates the cache.
  */
 export async function getSuggestedPrompts(): Promise<SuggestedPrompt[]> {
-  const prompts: SuggestedPrompt[] = [];
-
-  let deterministicPrompts: SuggestedPrompt[] = [];
-  try {
-    deterministicPrompts = await getDeterministicPrompts();
-    prompts.push(...deterministicPrompts);
-  } catch (err) {
-    log.warn({ err }, "Failed to compute deterministic suggested prompts");
-  }
-
   if (Date.now() - cachedLLMPromptsAt < LLM_CACHE_TTL_MS) {
-    prompts.push(...cachedLLMPrompts);
+    return [...cachedLLMPrompts];
   }
-
-  return prompts;
+  return [];
 }
 
 /**
- * Drops the in-memory LLM suggestion cache so the next call to
- * `getSuggestedPrompts()` returns only the fresh deterministic list (and
- * a follow-up background refresh repopulates the LLM half).
+ * Drops the in-memory suggestion cache so the next background refresh
+ * regenerates prompts with current integration state.
  *
- * Called from OAuth connect/disconnect paths so a freshly-connected
- * provider stops surfacing as a "Connect X" pill within one reload — the
- * 30-minute TTL would otherwise pin a stale suggestion until the next
- * periodic refresh.
+ * Called from OAuth connect/disconnect paths so suggestions reflect the
+ * new state within one reload instead of waiting for the 30-minute TTL.
  */
 export function invalidateAssistantSuggestedPromptsCache(): void {
   cachedLLMPrompts = [];
@@ -156,8 +80,7 @@ export async function refreshAssistantSuggestedPrompts(): Promise<void> {
   }
 
   try {
-    const deterministicPrompts = await getDeterministicPrompts();
-    const llmPrompts = await generateAssistantPrompts(deterministicPrompts);
+    const llmPrompts = await generateAssistantPrompts();
     cachedLLMPrompts = llmPrompts;
     cachedLLMPromptsAt = Date.now();
   } catch (err) {
@@ -165,49 +88,6 @@ export async function refreshAssistantSuggestedPrompts(): Promise<void> {
   }
 }
 
-/**
- * Check which well-known OAuth providers are not connected and return
- * a "Connect X" prompt for each. For connected providers that have
- * `connectedPrompts`, return those instead so users discover ongoing
- * management capabilities.
- */
-async function getDeterministicPrompts(): Promise<SuggestedPrompt[]> {
-  const providers = listProviders();
-  const prompts: SuggestedPrompt[] = [];
-
-  for (const provider of providers) {
-    const meta = CONNECT_PROMPT_META[provider.provider];
-    if (!meta) continue;
-
-    const connected = await isOAuthProviderConnected(provider.provider);
-
-    if (!connected) {
-      prompts.push({
-        id: `connect-${provider.provider}`,
-        label: meta.label,
-        icon: meta.icon,
-        prompt: meta.prompt,
-        source: "deterministic",
-      });
-      continue;
-    }
-
-    if (meta.connectedPrompts) {
-      for (const cp of meta.connectedPrompts) {
-        prompts.push({
-          id: `manage-${provider.provider}-${cp.label.toLowerCase().replace(/\s+/g, "-")}`,
-          label: cp.label,
-          icon: cp.icon,
-          prompt: cp.prompt,
-          source: "deterministic",
-        });
-      }
-    }
-  }
-
-  return prompts;
-}
-
 // ---------------------------------------------------------------------------
 // LLM-generated suggestions
 // ---------------------------------------------------------------------------
@@ -220,11 +100,9 @@ interface LLMSuggestion {
 /**
  * Ask the LLM to generate contextual conversation-starter suggestions
  * based on the assistant's persona and the user's connected services.
- * Returns an empty array on failure so deterministic prompts still show.
+ * Returns an empty array on failure.
  */
-async function generateAssistantPrompts(
-  deterministicPrompts: SuggestedPrompt[],
-): Promise<SuggestedPrompt[]> {
+async function generateAssistantPrompts(): Promise<SuggestedPrompt[]> {
   const config = getConfig();
   const resolved = resolveCallSiteConfig("homeSuggestedPrompts", config.llm);
 
@@ -238,17 +116,21 @@ async function generateAssistantPrompts(
     excludeCustomPrefix: true,
   });
 
-  const existingLabels = deterministicPrompts.map((p) => p.label).join(", ");
-  const contextNote = existingLabels
-    ? `The user already has these suggestions: ${existingLabels}. Do NOT duplicate them.`
-    : "";
+  let integrationContext = "";
+  try {
+    integrationContext = `\nConnected integrations: ${await formatIntegrationSummary()}`;
+  } catch {
+    // Best-effort — continue without integration info
+  }
 
   const result = await runBtwSidechain({
     content:
       "Suggest 2-3 short, actionable conversation starters for the home page. " +
       "Each should be something specific and helpful you can do for the user right now. " +
-      `${contextNote} ` +
-      'Return ONLY a JSON array of objects with "label" (max 5 words) and "prompt" (the full message to send). ' +
+      "Focus on things the user's connected services enable — don't suggest connecting services they already have. " +
+      "You may suggest connecting a service only if it's not yet connected and would be genuinely useful." +
+      integrationContext +
+      ' Return ONLY a JSON array of objects with "label" (max 5 words) and "prompt" (the full message to send). ' +
       "No markdown fences, no explanation.",
     provider,
     systemPrompt,

package/src/ipc/__tests__/cli-ipc.test.ts

@@ -37,6 +37,7 @@ mock.module("../../runtime/agent-wake.js", () => ({
 
 mock.module("../../memory/conversation-crud.js", () => ({
   getConversation: (id: string) => ({ id, createdAt: Date.now() }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // ---------------------------------------------------------------------------

package/src/ipc/gateway-client.test.ts

@@ -108,7 +108,10 @@ describe("ipcGetFeatureFlags", () => {
   });
 
   test("returns empty record when IPC returns undefined", async () => {
-    // No mock configured — ipcCall returns undefined
+    // Explicitly suppress the mock's default `get_feature_flags` sentinel
+    // (which exists to short-circuit `initFeatureFlagOverrides()`'s retry
+    // loop) so this test exercises the underlying-undefined path.
+    mockGatewayIpc(null, { results: { get_feature_flags: undefined } });
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({});
   });

package/src/ipc/skill-routes/__tests__/memory.test.ts

@@ -24,6 +24,7 @@ const addMessageSpy = mock(
 );
 mock.module("../../../memory/conversation-crud.js", () => ({
   addMessage: addMessageSpy,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 const wakeAgentSpy = mock(

package/src/ipc/skill-routes/__tests__/registries.test.ts

@@ -19,6 +19,7 @@ import {
   __clearExternalToolProvidersForTesting,
   __clearRegistryForTesting,
   getTool,
+  getToolOwner,
 } from "../../../tools/registry.js";
 import {
   __getActiveSessionCountForTesting,
@@ -55,7 +56,12 @@ afterEach(() => {
 
 describe("host.registries.register_tools", () => {
   test("installs proxy tools into the daemon's external tool registry", async () => {
+    // `skillId` lives at the top of the params object (one frame = one
+    // skill's batch). The per-tool manifest schema no longer carries an
+    // `owner` field — ownership flows in through this top-level key and
+    // is recorded in the registry's `ownersByName` map.
     const result = (await registerToolsRoute.handler({
+      skillId: "demo-skill",
       tools: [
         {
           name: "skill_demo_tool",
@@ -64,7 +70,6 @@ describe("host.registries.register_tools", () => {
           defaultRiskLevel: "low",
           category: "skill",
           executionTarget: "sandbox",
-          ownerSkillId: "demo-skill",
         },
       ],
     })) as { registered: string[] };
@@ -72,13 +77,17 @@ describe("host.registries.register_tools", () => {
     expect(result.registered).toEqual(["skill_demo_tool"]);
     const installed = getTool("skill_demo_tool");
     expect(installed).toBeDefined();
-    expect(installed!.origin).toBe("skill");
-    expect(installed!.ownerSkillId).toBe("demo-skill");
-    expect(installed!.executionMode).toBe("proxy");
+    // Ownership lives on the registry — getToolOwner is the single source of
+    // truth. The Tool object itself no longer carries the kind.
+    expect(getToolOwner("skill_demo_tool")).toEqual({
+      kind: "skill",
+      id: "demo-skill",
+    });
   });
 
   test("proxy execute throws when no supervisor is attached", async () => {
     await registerToolsRoute.handler({
+      skillId: "stub-skill",
       tools: [
         {
           name: "skill_stub_tool",
@@ -86,7 +95,6 @@ describe("host.registries.register_tools", () => {
           input_schema: { type: "object" },
           defaultRiskLevel: "medium",
           category: "skill",
-          ownerSkillId: "stub-skill",
         },
       ],
     });
@@ -106,16 +114,37 @@ describe("host.registries.register_tools", () => {
   });
 
   test("rejects empty tool list", async () => {
-    await expect(registerToolsRoute.handler({ tools: [] })).rejects.toThrow();
+    await expect(
+      registerToolsRoute.handler({ skillId: "any-skill", tools: [] }),
+    ).rejects.toThrow();
   });
 
   test("rejects missing required fields", async () => {
     await expect(
       registerToolsRoute.handler({
+        skillId: "any-skill",
         tools: [{ name: "missing_rest" }],
       }),
     ).rejects.toThrow();
   });
+
+  test("rejects missing skillId", async () => {
+    // skillId is the only place ownership flows in over IPC — without it
+    // the registry can't claim the tools, so the handler must reject.
+    await expect(
+      registerToolsRoute.handler({
+        tools: [
+          {
+            name: "skill_orphan_tool",
+            description: "no owner",
+            input_schema: { type: "object" },
+            defaultRiskLevel: "low",
+            category: "skill",
+          },
+        ],
+      }),
+    ).rejects.toThrow();
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -302,6 +331,7 @@ describe("lazy-external short-circuit", () => {
 
     const result = (await registerToolsRoute.handler(
       {
+        skillId: "demo-skill",
         tools: [
           {
             name: "skill_demo_tool",
@@ -309,7 +339,6 @@ describe("lazy-external short-circuit", () => {
             input_schema: {},
             defaultRiskLevel: "low",
             category: "skill",
-            ownerSkillId: "demo-skill",
           },
         ],
       },

package/src/ipc/skill-routes/memory.ts

@@ -17,13 +17,14 @@ import type { SkillIpcRoute } from "../skill-ipc-types.js";
 
 /**
  * Shape mirrors the daemon's `addMessage()` positional signature:
- * `(conversationId, role, content, metadata?, opts?)`. Metadata is a
- * free-form record (validated downstream by `messageMetadataSchema` with a
+ * `(conversationId, role, content, metadata?, opts?)`. `role` is
+ * constrained to the `MessageRole` union. Metadata is a free-form
+ * record (validated downstream by `messageMetadataSchema` with a
  * warn-and-store fallback). Only `skipIndexing` is recognised in `opts`.
  */
 const MemoryAddMessageParams = z.object({
   conversationId: z.string().min(1),
-  role: z.string().min(1),
+  role: z.enum(["user", "assistant", "system"]),
   content: z.string(),
   metadata: z.record(z.string(), z.unknown()).optional(),
   opts: z

package/src/ipc/skill-routes/registries.ts

@@ -48,18 +48,19 @@ const ToolManifestSchema = z.object({
   defaultRiskLevel: z.enum(["low", "medium", "high"]),
   category: z.string().min(1),
   executionTarget: z.enum(["sandbox", "host"]).optional(),
-  executionMode: z.enum(["local", "proxy"]).optional(),
-  // Required so disconnect can decrement the tool-registry refcount: a
-  // tool registered without an owner has no ref-counted entry to drop and
-  // would leak into the global registry on socket close.
-  ownerSkillId: z.string().min(1),
-  ownerSkillBundled: z.boolean().optional(),
-  ownerSkillVersionHash: z.string().optional(),
 });
 
 export type ToolManifest = z.infer<typeof ToolManifestSchema>;
 
+// `skillId` lives at the params level rather than per-tool: a single
+// `register_tools` IPC frame is always one skill's batch, ownership flows
+// through `registerSkillTools(skillId, tools)` into the registry's
+// `ownersByName` map, and the tools themselves stay free of owner
+// metadata so callers cannot spoof ownership by forging a field on the
+// manifest. Only skill-owned tools cross IPC — plugin and MCP tools live
+// in-process on the assistant side.
 const RegisterToolsParams = z.object({
+  skillId: z.string().min(1),
   tools: z.array(ToolManifestSchema).min(1),
 });
 
@@ -187,16 +188,10 @@ function buildProxyTool(manifest: ToolManifest): Tool {
     input_schema: manifest.input_schema as object,
     category: manifest.category,
     defaultRiskLevel: manifest.defaultRiskLevel as RiskLevel,
-    executionMode: manifest.executionMode ?? "proxy",
     executionTarget: resolveExecutionTarget({
       name: manifest.name,
       executionTarget: manifest.executionTarget as ExecutionTarget | undefined,
-      executionMode: manifest.executionMode ?? "proxy",
     }),
-    origin: "skill",
-    ownerSkillId: manifest.ownerSkillId,
-    ownerSkillBundled: manifest.ownerSkillBundled,
-    ownerSkillVersionHash: manifest.ownerSkillVersionHash,
     execute: async () => {
       // Only reached when no supervisor is attached (tests/boot race);
       // the supervisor short-circuit above replaces this with the
@@ -214,7 +209,7 @@ async function handleRegisterTools(
   params: Record<string, unknown> | undefined,
   connection?: unknown,
 ): Promise<{ registered: string[] }> {
-  const { tools } = RegisterToolsParams.parse(params);
+  const { skillId, tools } = RegisterToolsParams.parse(params);
   const conn = connection as SkillIpcConnection | undefined;
 
   // Supervisor short-circuit: when a supervisor is registered, the
@@ -226,7 +221,11 @@ async function handleRegisterTools(
   if (sessionSupervisor) {
     if (conn) sessionSupervisor.setActiveConnection(conn);
     log.info(
-      { count: tools.length, names: tools.map((t) => t.name) },
+      {
+        count: tools.length,
+        names: tools.map((t) => t.name),
+        ownerSkillId: skillId,
+      },
       "Supervisor active: skipping in-memory tool re-registration; manifest proxies serve dispatches",
     );
     return { registered: tools.map((t) => t.name) };
@@ -236,23 +235,23 @@ async function handleRegisterTools(
   // `registerExternalTools` is only consumed inside `initializeTools()` at
   // daemon boot; IPC children connect after boot, so route through
   // `registerSkillTools` into the live registry the agent-loop reads from.
-  const accepted = registerSkillTools(proxies);
-
-  // `registerSkillTools` increments the registry refcount once per unique
-  // ownerSkillId in the batch; mirror that on the connection so disconnect
-  // issues exactly the matching number of decrements.
-  if (conn) {
-    const ownerIds = new Set<string>();
-    for (const tool of accepted) {
-      if (tool.ownerSkillId) ownerIds.add(tool.ownerSkillId);
-    }
-    for (const skillId of ownerIds) {
-      conn.addSkillToolsOwner(skillId);
-    }
+  // Owner is stamped registry-side from `skillId`; the proxy `Tool` objects
+  // carry no owner field.
+  const accepted = registerSkillTools(skillId, proxies);
+
+  // `registerSkillTools` increments the registry refcount once per call;
+  // mirror that on the connection so disconnect issues exactly one matching
+  // decrement.
+  if (conn && accepted.length > 0) {
+    conn.addSkillToolsOwner(skillId);
   }
 
   log.info(
-    { count: accepted.length, names: accepted.map((t) => t.name) },
+    {
+      count: accepted.length,
+      names: accepted.map((t) => t.name),
+      ownerSkillId: skillId,
+    },
     "Registered skill proxy tools via IPC",
   );
   return { registered: accepted.map((t) => t.name) };

package/src/memory/__tests__/jobs-store-enqueue-gate.test.ts

@@ -57,6 +57,7 @@ mock.module("../../runtime/actor-trust-resolver.js", () => ({
 // retrospective and auto-analysis paths fall through to the enqueue.
 mock.module("../conversation-crud.js", () => ({
   getConversationSource: () => null,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 mock.module("../auto-analysis-guard.js", () => ({
   isAutoAnalysisConversation: () => false,

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

@@ -34,11 +34,9 @@ import {
 
 import { eq } from "drizzle-orm";
 
-import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
+import { createMockLoggerModule } from "../../__tests__/helpers/mock-logger.js";
 
-mock.module("../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
+mock.module("../../util/logger.js", () => createMockLoggerModule());
 
 // Workspace pin must precede the `db` import below — the DB singleton
 // resolves its path at first call, so we need the env var set before
@@ -279,10 +277,33 @@ describe("maybeEnqueueGraphMaintenanceJobs — buffer-size trigger", () => {
     maybeEnqueueGraphMaintenanceJobs(config, now);
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
-    // Checkpoint refreshed so the next tick doesn't immediately re-fire.
+    // Checkpoint refreshed so the time-based branch doesn't re-fire.
     expect(getMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY)).toBe(String(now));
   });
 
+  test("does not re-fire on every tick while buffer stays over threshold", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      intervalHours: 1,
+      maxBufferLines: 5,
+    });
+
+    const now = Date.now();
+    // Recent checkpoint so the time-based branch never fires across ticks —
+    // the only thing that could re-enqueue is the size branch.
+    setMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY, String(now - 60_000));
+    writeBuffer(10);
+
+    // Simulate several worker ticks with the buffer still over threshold and
+    // the first-tick job still pending (nothing has drained it yet).
+    maybeEnqueueGraphMaintenanceJobs(config, now);
+    maybeEnqueueGraphMaintenanceJobs(config, now + 1_000);
+    maybeEnqueueGraphMaintenanceJobs(config, now + 2_000);
+
+    // A pending consolidate job dedupes the later ticks — only one enqueue.
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+  });
+
   test("does not enqueue when buffer is under the threshold", () => {
     const config = buildConfig({
       v2Enabled: true,

package/src/memory/__tests__/memory-retrospective-enqueue.test.ts

@@ -19,6 +19,7 @@ const upsertCalls: Array<{
 
 mock.module("../conversation-crud.js", () => ({
   getConversationSource: (_id: string) => sourceTag,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../jobs-store.js", () => ({

package/src/memory/__tests__/memory-retrospective-job.test.ts

@@ -144,6 +144,7 @@ mock.module("../conversation-crud.js", () => ({
   deleteConversation: (id: string) => {
     deletedConversationIds.push(id);
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../../config/assistant-feature-flags.js", () => ({

package/src/memory/__tests__/memory-retrospective-startup-cleanup.test.ts

@@ -108,6 +108,7 @@ mock.module("../conversation-crud.js", () => ({
     deletedIds.push(id);
     mockConversations = mockConversations.filter((c) => c.id !== id);
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 import { sweepOrphanMemoryRetrospectiveConversations } from "../memory-retrospective-startup-cleanup.js";

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

@@ -187,4 +187,35 @@ describe("memory-v2-activation-log-store", () => {
     expect(byTurn.get(2)!.messageId).toBe("msg-a");
     expect(byTurn.get(3)!.messageId).toBe("msg-b");
   });
+
+  test("backfill skips v3_shadow rows, leaving their messageId null", () => {
+    const conversationId = "conv-shadow-backfill";
+
+    // A live router row (null messageId) and a detached v3_shadow row (null
+    // messageId) coexist in the same conversation.
+    recordMemoryV2ActivationLog({
+      conversationId,
+      turn: 5,
+      mode: "router",
+      concepts: sampleConcepts,
+      config: sampleConfig,
+    });
+    recordMemoryV2ActivationLog({
+      conversationId,
+      turn: 5,
+      mode: "v3_shadow",
+      concepts: sampleConcepts,
+      config: sampleConfig,
+    });
+
+    backfillMemoryV2ActivationMessageId(conversationId, "msg-live");
+
+    const db = getDb();
+    const rows = db.select().from(memoryV2ActivationLogs).all();
+    const byMode = new Map(rows.map((r) => [r.mode, r]));
+    // The live router row got stamped; the shadow row stayed null (not
+    // mis-attributed to the live message).
+    expect(byMode.get("router")!.messageId).toBe("msg-live");
+    expect(byMode.get("v3_shadow")!.messageId).toBeNull();
+  });
 });