@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/memory/conversation-queries.ts

@@ -73,6 +73,52 @@ function archiveStatusClause(status: ArchiveStatusFilter) {
   }
 }
 
+/**
+ * Raw SQL predicate for "visible in the standard (Recents) listing".
+ *
+ * Shared by the `"standard"` bucket of {@link conversationTypeClause} (list +
+ * count) and by every match path in {@link searchConversations} (FTS content,
+ * LIKE content fallback, and title LIKE) so the listing and search can never
+ * drift: anything the sidebar shows in Recents is also findable by search,
+ * and vice versa.
+ *
+ * Two arms:
+ * - Foreground rows: not background/scheduled/private by type, and not routed
+ *   to the `system:background` / `system:scheduled` groups.
+ * - Surfaced rows (`surfaced_at IS NOT NULL`): background/scheduled rows
+ *   explicitly promoted via the surface API. Private rows stay excluded
+ *   unconditionally, and subagent runs are excluded from the surfaced arm so
+ *   they can never reach the sidebar.
+ *
+ * @param alias Table name or alias qualifying the column references
+ *              (e.g. `"c"` in the search joins).
+ */
+function standardListingVisibilitySql(alias = "conversations"): string {
+  return (
+    `((${alias}.conversation_type NOT IN ('background', 'scheduled', 'private')` +
+    ` AND COALESCE(${alias}.group_id, 'system:all') NOT IN ('system:background', 'system:scheduled'))` +
+    ` OR ${surfacedVisibilitySql(alias)})`
+  );
+}
+
+/**
+ * Raw SQL predicate for the surfaced arm of standard-listing visibility:
+ * background/scheduled rows explicitly promoted via the surface API
+ * (`surfaced_at IS NOT NULL`), with private rows excluded unconditionally and
+ * subagent runs excluded so they can never reach the sidebar.
+ *
+ * Shared by {@link standardListingVisibilitySql} and
+ * {@link listPinnedConversations} so pinned surfaced rows stay visible
+ * everywhere the standard listing would show them.
+ */
+function surfacedVisibilitySql(alias = "conversations"): string {
+  return (
+    `(${alias}.surfaced_at IS NOT NULL` +
+    ` AND ${alias}.conversation_type != 'private'` +
+    ` AND (${alias}.source IS NULL OR ${alias}.source != 'subagent'))`
+  );
+}
+
 /**
  * SQL predicate selecting which bucket {@link listConversations} and
  * {@link countConversations} return, keyed by the canonical
@@ -82,7 +128,10 @@ function archiveStatusClause(status: ArchiveStatusFilter) {
  *   excluding background, scheduled, and private rows. `"private"` is excluded
  *   defensively because in-place snapshot restore swaps the SQLite file without
  *   running migrations in-process, so legacy private rows can briefly exist
- *   before migration cleanup deletes them.
+ *   before migration cleanup deletes them. Background/scheduled rows with a
+ *   non-null `surfaced_at` (explicitly promoted via the surface API) are
+ *   included so clients can render them in the Recents grouping without a
+ *   separate fetch.
  * - `"background"` — the background **umbrella**: background *and* scheduled
  *   rows together. The back-compat bucket for the single
  *   `conversationType=background` fetch that older clients (e.g. the macOS app,
@@ -101,7 +150,10 @@ function conversationTypeClause(type: ConversationType) {
   const notSubagent = sql`(${conversations.source} IS NULL OR ${conversations.source} != 'subagent')`;
   switch (type) {
     case "standard":
-      return sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private') AND COALESCE(group_id, 'system:all') NOT IN ('system:background', 'system:scheduled')`;
+      // Surfaced rows (`surfaced_at IS NOT NULL`) are promoted into the
+      // standard listing even when they're background/scheduled — see
+      // standardListingVisibilitySql for the full predicate semantics.
+      return sql.raw(standardListingVisibilitySql());
     case "background":
       return sql`(${conversations.conversationType} IN ('background', 'scheduled') OR group_id IN ('system:background', 'system:scheduled')) AND ${notSubagent}`;
     case "scheduled":
@@ -233,7 +285,13 @@ export function listPinnedConversations(
     .from(conversations)
     .where(
       and(
-        sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private')`,
+        // Mirror the standard listing: plain foreground rows by type, plus
+        // surfaced background/scheduled rows — a pinned surfaced conversation
+        // must stay injectable into page 1 (see surfacedVisibilitySql).
+        sql.raw(
+          `(conversations.conversation_type NOT IN ('background', 'scheduled', 'private')` +
+            ` OR ${surfacedVisibilitySql()})`,
+        ),
         sql`is_pinned = 1`,
         ...(archiveCond ? [archiveCond] : []),
       ),
@@ -417,7 +475,7 @@ export function searchConversations(
         FROM messages_fts f
         JOIN messages m ON m.id = f.message_id
         JOIN conversations c ON c.id = m.conversation_id
-        WHERE messages_fts MATCH ? AND c.conversation_type NOT IN ('background', 'scheduled', 'private') AND COALESCE(c.group_id, 'system:all') NOT IN ('system:background', 'system:scheduled') AND c.archived_at IS NULL
+        WHERE messages_fts MATCH ? AND ${standardListingVisibilitySql("c")} AND c.archived_at IS NULL
         LIMIT 1000
       `,
         ftsMatch,
@@ -442,7 +500,7 @@ export function searchConversations(
       SELECT DISTINCT m.conversation_id
       FROM messages m
       JOIN conversations c ON c.id = m.conversation_id
-      WHERE m.content LIKE ? ESCAPE '\\' AND c.conversation_type NOT IN ('background', 'scheduled', 'private') AND COALESCE(c.group_id, 'system:all') NOT IN ('system:background', 'system:scheduled') AND c.archived_at IS NULL
+      WHERE m.content LIKE ? ESCAPE '\\' AND ${standardListingVisibilitySql("c")} AND c.archived_at IS NULL
       LIMIT 1000
     `,
       likePattern,
@@ -456,8 +514,7 @@ export function searchConversations(
     .from(conversations)
     .where(
       and(
-        sql`${conversations.conversationType} NOT IN ('background', 'scheduled', 'private')`,
-        sql`COALESCE(group_id, 'system:all') NOT IN ('system:background', 'system:scheduled')`,
+        sql.raw(standardListingVisibilitySql()),
         sql`${conversations.title} LIKE ${titlePattern} ESCAPE '\\'`,
         sql`${conversations.archivedAt} IS NULL`,
       ),

package/src/memory/db-init.ts

@@ -37,6 +37,7 @@ import {
   createOnboardingEventsTable,
   createScopedApprovalGrantsTable,
   createSequenceTables,
+  createSkillLoadedEventsTable,
   createTasksAndWorkItemsTables,
   createWatchersAndLogsTables,
   migrate230AcpSessionHistory,
@@ -46,6 +47,7 @@ import {
   migrateActivationState,
   migrateActivationStateFkCascade,
   migrateAddConversationInferenceProfile,
+  migrateAddMemoryV3EverInjected,
   migrateAddMemoryV3Selections,
   migrateAddSourceTypeColumns,
   migrateAssistantContactMetadata,
@@ -77,6 +79,7 @@ import {
   migrateConversationLastNotifiedProfile,
   migrateConversationsArchivedAt,
   migrateConversationsLastMessageAt,
+  migrateConversationsSurfacedAt,
   migrateConversationsThreadTypeIndex,
   migrateCreateConversationGraphMemoryState,
   migrateCreateDocumentComments,
@@ -186,6 +189,7 @@ import {
   migrateRenameVerificationSessionIdColumn,
   migrateRenameVerificationTable,
   migrateRenameVoiceToPhone,
+  migrateScheduleDescription,
   migrateScheduleOneShotRouting,
   migrateScheduleQuietFlag,
   migrateScheduleRetryPolicy,
@@ -201,7 +205,10 @@ import {
   migrateStripIntegrationPrefixFromProviderKeys,
   migrateStripPlaceholderSentinelsFromMessages,
   migrateStripThinkingFromConsolidated,
+  migrateToolInvocationsCreatedAtIdIndex,
   migrateToolInvocationsMatchedRuleId,
+  migrateToolInvocationsSkillId,
+  migrateToolInvocationsTelemetryColumns,
   migrateTraceEventsCreatedAtIndex,
   migrateUsageDashboardIndexes,
   migrateUsageLlmCallCount,
@@ -478,12 +485,19 @@ export function initializeDb(): void {
     migrateLlmUsageEventsAddAssistantVersion,
     migrateAddMemoryV3Selections,
     migrateScheduleScriptTimeout,
+    migrateScheduleDescription,
     migrateScheduleSourceConversation,
     migrateMessagesRoleCreatedAtIndex,
     createAuthFallbackEventsTable,
     migrateAcpSessionHistoryCwd,
     migrateOnboardingEventsFunnelColumns,
     createActivationSessionsTable,
+    migrateToolInvocationsSkillId,
+    migrateToolInvocationsCreatedAtIdIndex,
+    migrateAddMemoryV3EverInjected,
+    migrateToolInvocationsTelemetryColumns,
+    createSkillLoadedEventsTable,
+    migrateConversationsSurfacedAt,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/embedding-backend.test.ts

@@ -1,12 +1,33 @@
-import { afterEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AssistantConfig } from "../config/types.js";
 import {
   clearEmbeddingBackendCache,
+  embedWithBackend,
   resetLocalEmbeddingFailureState,
   selectEmbeddingBackend,
 } from "./embedding-backend.js";
 
+const getProviderKeyAsyncMock = mock(
+  async (_provider: string): Promise<string | undefined> => undefined,
+);
+mock.module("../security/secure-keys.js", () => ({
+  getProviderKeyAsync: getProviderKeyAsyncMock,
+}));
+
+const DISABLED_PROXY_CONTEXT = {
+  enabled: false,
+  platformBaseUrl: "",
+  assistantApiKey: "",
+};
+const resolveManagedProxyContextMock = mock(async () => DISABLED_PROXY_CONTEXT);
+mock.module("../providers/platform-proxy/context.js", () => ({
+  resolveManagedProxyContext: resolveManagedProxyContextMock,
+  hasManagedProxyPrereqs: mock(async () => false),
+  buildManagedBaseUrl: mock(async () => undefined),
+  managedFallbackEnabledFor: mock(async () => false),
+}));
+
 const LOCAL_CONFIG = {
   memory: {
     embeddings: {
@@ -73,3 +94,111 @@ describe("embedding backend cache invalidation", () => {
     expect(secondSelection.backend).toBe(firstSelection.backend);
   });
 });
+
+const GEMINI_CONFIG = {
+  memory: {
+    embeddings: {
+      provider: "gemini",
+      geminiModel: "test-model",
+    },
+    qdrant: {
+      vectorSize: 3,
+    },
+  },
+} as unknown as AssistantConfig;
+
+const ENABLED_PROXY_CONTEXT = {
+  enabled: true,
+  platformBaseUrl: "https://proxy.example.com",
+  assistantApiKey: "stale-platform-key",
+};
+
+function jsonResponse(body: unknown, status: number): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+describe("managed-proxy Gemini fallback to direct key", () => {
+  const originalFetch = globalThis.fetch;
+  let fetchMock: ReturnType<typeof mock>;
+
+  beforeEach(() => {
+    clearEmbeddingBackendCache();
+    // Managed-proxy requests (proxy.example.com) are rejected like a platform
+    // proxy with a bad credential; direct Google API requests succeed.
+    fetchMock = mock(async (url: string | URL) => {
+      if (String(url).startsWith("https://proxy.example.com/")) {
+        return jsonResponse({ detail: "Invalid or revoked API key." }, 403);
+      }
+      return jsonResponse({ embedding: { values: [0.1, 0.2, 0.3] } }, 200);
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    clearEmbeddingBackendCache();
+    getProviderKeyAsyncMock.mockReset();
+    getProviderKeyAsyncMock.mockImplementation(async () => undefined);
+    resolveManagedProxyContextMock.mockReset();
+    resolveManagedProxyContextMock.mockImplementation(
+      async () => DISABLED_PROXY_CONTEXT,
+    );
+  });
+
+  test("falls back to the direct key when the managed-proxy primary fails", async () => {
+    resolveManagedProxyContextMock.mockImplementation(
+      async () => ENABLED_PROXY_CONTEXT,
+    );
+    getProviderKeyAsyncMock.mockImplementation(async (provider) =>
+      provider === "gemini" ? "direct-key" : undefined,
+    );
+
+    const result = await embedWithBackend(GEMINI_CONFIG, ["hello world"]);
+
+    expect(result.provider).toBe("gemini");
+    expect(result.vectors).toEqual([[0.1, 0.2, 0.3]]);
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    const [managedUrl, managedInit] = fetchMock.mock.calls[0] as [
+      string,
+      RequestInit,
+    ];
+    expect(managedUrl).toBe(
+      "https://proxy.example.com/v1/runtime-proxy/gemini/v1beta/models/test-model:embedContent",
+    );
+    expect(
+      (managedInit.headers as Record<string, string>)["Authorization"],
+    ).toBe("Bearer stale-platform-key");
+    const [directUrl] = fetchMock.mock.calls[1] as [string, RequestInit];
+    expect(directUrl).toContain("generativelanguage.googleapis.com");
+    expect(directUrl).toContain("key=direct-key");
+  });
+
+  test("surfaces the managed-proxy error when no direct key exists", async () => {
+    resolveManagedProxyContextMock.mockImplementation(
+      async () => ENABLED_PROXY_CONTEXT,
+    );
+
+    await expect(
+      embedWithBackend(GEMINI_CONFIG, ["hello world"]),
+    ).rejects.toThrow(/403/);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("uses the direct key as primary when the managed proxy is disabled", async () => {
+    getProviderKeyAsyncMock.mockImplementation(async (provider) =>
+      provider === "gemini" ? "direct-key" : undefined,
+    );
+
+    const result = await embedWithBackend(GEMINI_CONFIG, ["another input"]);
+
+    expect(result.vectors).toEqual([[0.1, 0.2, 0.3]]);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [directUrl] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(directUrl).toContain("generativelanguage.googleapis.com");
+    expect(directUrl).toContain("key=direct-key");
+  });
+});

package/src/memory/embedding-backend.ts

@@ -1,6 +1,5 @@
 import { createHash } from "node:crypto";
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getOllamaBaseUrlEnv } from "../config/env.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import type { AssistantConfig } from "../config/types.js";
@@ -267,6 +266,56 @@ function geminiCacheExtras(config: AssistantConfig): string[] {
   return extras;
 }
 
+/** Build (or reuse) the direct-API Gemini backend for the given key. */
+function getDirectGeminiBackend(
+  config: AssistantConfig,
+  geminiKey: string,
+): EmbeddingBackend {
+  return getCachedOrCreate(
+    "gemini",
+    config.memory.embeddings.geminiModel,
+    () =>
+      new GeminiEmbeddingBackend(
+        geminiKey,
+        config.memory.embeddings.geminiModel,
+        {
+          taskType: config.memory.embeddings.geminiTaskType,
+          dimensions: config.memory.embeddings.geminiDimensions,
+        },
+      ),
+    geminiCacheExtras(config),
+  );
+}
+
+/**
+ * Build (or reuse) the managed-proxy Gemini backend, or return undefined
+ * when the managed proxy prerequisites (platform URL + assistant API key)
+ * are not satisfied.
+ */
+async function tryGetManagedGeminiBackend(
+  config: AssistantConfig,
+): Promise<EmbeddingBackend | undefined> {
+  const proxyCtx = await resolveManagedProxyContext();
+  const meta = PLATFORM_PROVIDER_META["gemini"];
+  if (!proxyCtx.enabled || !meta?.managed || !meta.proxyPath) return undefined;
+  const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
+  return getCachedOrCreate(
+    "gemini",
+    config.memory.embeddings.geminiModel,
+    () =>
+      new GeminiEmbeddingBackend(
+        proxyCtx.assistantApiKey,
+        config.memory.embeddings.geminiModel,
+        {
+          taskType: config.memory.embeddings.geminiTaskType,
+          dimensions: config.memory.embeddings.geminiDimensions ?? 3072,
+          managedBaseUrl,
+        },
+      ),
+    [...geminiCacheExtras(config), "managed"],
+  );
+}
+
 export interface EmbeddingBackendSelection {
   backend: EmbeddingBackend | null;
   reason: string | null;
@@ -302,41 +351,13 @@ export async function selectEmbeddingBackend(
     };
   }
 
-  // When the managed-gemini-embeddings-enabled flag is on AND managed proxy
-  // prerequisites are satisfied, insert managed-proxy Gemini at the front of
-  // the auto chain so platform assistants use Vellum-managed Gemini embeddings.
-  if (
-    (requested === "auto" || requested === "gemini") &&
-    isAssistantFeatureFlagEnabled("managed-gemini-embeddings-enabled", config)
-  ) {
-    const proxyCtx = await resolveManagedProxyContext();
-    if (proxyCtx.enabled) {
-      const meta = PLATFORM_PROVIDER_META["gemini"];
-      if (meta?.managed && meta.proxyPath) {
-        const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
-        const managedModel = config.memory.embeddings.geminiModel;
-        const managedDimensions =
-          config.memory.embeddings.geminiDimensions ?? 3072;
-        const extras = geminiCacheExtras(config);
-        return {
-          backend: getCachedOrCreate(
-            "gemini",
-            managedModel,
-            () =>
-              new GeminiEmbeddingBackend(
-                proxyCtx.assistantApiKey,
-                managedModel,
-                {
-                  taskType: config.memory.embeddings.geminiTaskType,
-                  dimensions: managedDimensions,
-                  managedBaseUrl,
-                },
-              ),
-            [...extras, "managed"],
-          ),
-          reason: null,
-        };
-      }
+  // When managed proxy prerequisites are satisfied, insert managed-proxy Gemini
+  // at the front of the auto chain so platform assistants use Vellum-managed
+  // Gemini embeddings.
+  if (requested === "auto" || requested === "gemini") {
+    const managed = await tryGetManagedGeminiBackend(config);
+    if (managed) {
+      return { backend: managed, reason: null };
     }
   }
 
@@ -405,20 +426,7 @@ export async function selectEmbeddingBackend(
           continue;
         }
         return {
-          backend: getCachedOrCreate(
-            "gemini",
-            config.memory.embeddings.geminiModel,
-            () =>
-              new GeminiEmbeddingBackend(
-                geminiKey,
-                config.memory.embeddings.geminiModel,
-                {
-                  taskType: config.memory.embeddings.geminiTaskType,
-                  dimensions: config.memory.embeddings.geminiDimensions,
-                },
-              ),
-            geminiCacheExtras(config),
-          ),
+          backend: getDirectGeminiBackend(config, geminiKey),
           reason: null,
         };
       }
@@ -454,7 +462,7 @@ export async function getMemoryBackendStatus(config: AssistantConfig): Promise<{
   model: string | null;
   reason: string | null;
 }> {
-  if (!config.memory.enabled) {
+  if (config.memory.enabled === false) {
     return {
       enabled: false,
       degraded: false,
@@ -511,6 +519,21 @@ export async function embedWithBackend(
       ? await selectFallbackBackends(config, selection.backend.provider)
       : [];
 
+  // A managed-proxy Gemini primary can fail at the proxy (e.g. a stale or
+  // revoked platform credential) while a valid direct Gemini key sits in the
+  // credential store. The provider-level chain above never includes Gemini
+  // when Gemini IS the primary, so without this the direct key would never
+  // be tried and the provider would stay down for the whole process.
+  if (
+    selection.backend instanceof GeminiEmbeddingBackend &&
+    selection.backend.managed
+  ) {
+    const geminiKey = await getProviderKeyAsync("gemini");
+    if (geminiKey) {
+      fallbacks.push(getDirectGeminiBackend(config, geminiKey));
+    }
+  }
+
   // ── Compute provider-specific vector cache extras ───────────────
   const vectorExtras =
     primaryProvider === "gemini" ? geminiCacheExtras(config) : undefined;
@@ -661,54 +684,12 @@ async function selectFallbackBackends(
       case "gemini": {
         const geminiKey = await getProviderKeyAsync("gemini");
         if (geminiKey) {
-          backends.push(
-            getCachedOrCreate(
-              "gemini",
-              config.memory.embeddings.geminiModel,
-              () =>
-                new GeminiEmbeddingBackend(
-                  geminiKey,
-                  config.memory.embeddings.geminiModel,
-                  {
-                    taskType: config.memory.embeddings.geminiTaskType,
-                    dimensions: config.memory.embeddings.geminiDimensions,
-                  },
-                ),
-              geminiCacheExtras(config),
-            ),
-          );
-        } else if (
-          isAssistantFeatureFlagEnabled(
-            "managed-gemini-embeddings-enabled",
-            config,
-          )
-        ) {
+          backends.push(getDirectGeminiBackend(config, geminiKey));
+        } else {
           // Try managed proxy Gemini as fallback when no direct key exists.
-          const proxyCtx = await resolveManagedProxyContext();
-          const meta = PLATFORM_PROVIDER_META["gemini"];
-          if (proxyCtx.enabled && meta?.managed && meta.proxyPath) {
-            const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
-            const managedModel = config.memory.embeddings.geminiModel;
-            const managedDimensions =
-              config.memory.embeddings.geminiDimensions ?? 3072;
-            const extras = geminiCacheExtras(config);
-            backends.push(
-              getCachedOrCreate(
-                "gemini",
-                managedModel,
-                () =>
-                  new GeminiEmbeddingBackend(
-                    proxyCtx.assistantApiKey,
-                    managedModel,
-                    {
-                      taskType: config.memory.embeddings.geminiTaskType,
-                      dimensions: managedDimensions,
-                      managedBaseUrl,
-                    },
-                  ),
-                [...extras, "managed"],
-              ),
-            );
+          const managed = await tryGetManagedGeminiBackend(config);
+          if (managed) {
+            backends.push(managed);
           } else {
             // Check managed cache variant first, then non-managed, so a warm
             // managed backend survives transient proxy-context blips.
@@ -724,14 +705,6 @@ async function selectFallbackBackends(
               );
             if (cached) backends.push(cached);
           }
-        } else {
-          // Preserve cached backend on transient credential-store failures.
-          const cached = getCached(
-            "gemini",
-            config.memory.embeddings.geminiModel,
-            geminiCacheExtras(config),
-          );
-          if (cached) backends.push(cached);
         }
         break;
       }

package/src/memory/embedding-gemini.ts

@@ -36,6 +36,11 @@ export class GeminiEmbeddingBackend implements EmbeddingBackend {
     this.managedBaseUrl = options?.managedBaseUrl;
   }
 
+  /** True when requests route through the managed platform proxy. */
+  get managed(): boolean {
+    return Boolean(this.managedBaseUrl);
+  }
+
   async embed(
     inputs: EmbeddingInput[],
     options?: EmbeddingRequestOptions,

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

@@ -173,6 +173,10 @@ const { applyNestedDefaults } = await import("../../../config/loader.js");
 const { getSqliteFrom } = await import("../../db-connection.js");
 const { migrateActivationState } =
   await import("../../migrations/232-activation-state.js");
+const { migrateAddMemoryV3EverInjected } =
+  await import("../../migrations/277-add-memory-v3-ever-injected.js");
+const { getActiveSlugs: getV3ActiveSlugs, recordInjected: recordV3Injected } =
+  await import("../../../plugins/defaults/memory-v3-shadow/ever-injected-store.js");
 const schema = await import("../../schema.js");
 const { _resetMemoryV2QdrantForTests } = await import("../../v2/qdrant.js");
 const { hydrate: hydrateActivationState, save: saveActivationState } =
@@ -210,6 +214,8 @@ function createTestDb(): DrizzleDb {
     )
   `);
   migrateActivationState(db);
+  // `onCompacted` also clears memory-v3's everInjected record.
+  migrateAddMemoryV3EverInjected(db);
   return db;
 }
 
@@ -589,10 +595,16 @@ describe("ConversationGraphMemory.onCompacted — v2 activation eviction", () =>
     const before = await hydrateActivationState(testDbHandle!, conversationId);
     expect(before?.everInjected.map((e) => e.slug)).toContain("alice-vscode");
 
+    // Seed a memory-v3 everInjected record too: the same trigger clears it
+    // (the frozen card blocks those slugs rode were just compacted away).
+    recordV3Injected(conversationId, [{ slug: "alice-vscode", bytes: 100 }]);
+    expect(getV3ActiveSlugs(conversationId)).toEqual(new Set(["alice-vscode"]));
+
     await memory.onCompacted(1);
 
     const after = await hydrateActivationState(testDbHandle!, conversationId);
     expect(after?.everInjected).toEqual([]);
+    expect(getV3ActiveSlugs(conversationId)).toEqual(new Set());
 
     // Turn 2 — same Qdrant relevance. With everInjected cleared the slug
     // should appear again in the injection block (re-attached on the new

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

@@ -60,6 +60,10 @@ const { handleRemember } = await import("../tool-handlers.js");
 const { applyNestedDefaults } = await import("../../../config/loader.js");
 
 const CONFIG = applyNestedDefaults({});
+const CONFIG_MEMORY_OFF = {
+  ...CONFIG,
+  memory: { ...CONFIG.memory, enabled: false },
+};
 const CONFIG_V2_OFF = {
   ...CONFIG,
   memory: { ...CONFIG.memory, v2: { ...CONFIG.memory.v2, enabled: false } },
@@ -81,6 +85,21 @@ function todaysArchiveBasename(now: Date = new Date()): string {
 }
 
 describe("handleRemember — memory.v2.enabled on", () => {
+  test("does not write when global memory is disabled", () => {
+    const result = handleRemember(
+      { content: "do not save this" },
+      "conv-memory-off",
+      "default",
+      CONFIG_MEMORY_OFF,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("Memory is disabled");
+    expect(existsSync(join(tmpWorkspace, "memory", "buffer.md"))).toBe(false);
+    expect(existsSync(join(tmpWorkspace, "pkb", "buffer.md"))).toBe(false);
+    expect(enqueueCalls).toEqual([]);
+  });
+
   test("writes to memory/buffer.md and memory/archive/<today>.md", () => {
     const result = handleRemember(
       { content: "Alice prefers VS Code over Vim" },