@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/providers/openai/__tests__/tool-choice-mapping.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+
+import type { Message, ToolDefinition } from "../../types.js";
+import {
+  mapNeutralToolChoice,
+  OpenAIChatCompletionsProvider,
+} from "../chat-completions-provider.js";
+import { mapNeutralToolChoiceForResponses } from "../responses-provider.js";
+
+const TOOLS: ToolDefinition[] = [
+  {
+    name: "bash",
+    description: "Run a shell command",
+    input_schema: { type: "object", properties: {} },
+  },
+];
+
+const USER_MESSAGE: Message[] = [
+  { role: "user", content: [{ type: "text", text: "hi" }] },
+];
+
+/**
+ * Stub the SDK client so we can capture the outgoing chat.completions.create
+ * params without hitting the network.
+ */
+function stubChatProvider(): {
+  provider: OpenAIChatCompletionsProvider;
+  requests: Array<Record<string, unknown>>;
+} {
+  const provider = new OpenAIChatCompletionsProvider("test-key", "test-model");
+  const requests: Array<Record<string, unknown>> = [];
+  (provider as unknown as { client: unknown }).client = {
+    chat: {
+      completions: {
+        create: async (params: Record<string, unknown>) => {
+          requests.push(params);
+          return {
+            async *[Symbol.asyncIterator]() {
+              yield {
+                choices: [{ delta: {}, finish_reason: "stop" }],
+                usage: { prompt_tokens: 1, completion_tokens: 1 },
+              };
+            },
+          };
+        },
+      },
+    },
+  };
+  return { provider, requests };
+}
+
+describe("mapNeutralToolChoice (chat-completions wire format)", () => {
+  // Each neutral tool_choice variant maps to its OpenAI-compatible form.
+  test("maps the Anthropic-shaped union to OpenAI's tool_choice values", () => {
+    // GIVEN the neutral (Anthropic-shaped) tool_choice union
+    // WHEN each variant is mapped to the chat-completions wire format
+    // THEN it produces the OpenAI-compatible value
+    expect(mapNeutralToolChoice({ type: "auto" })).toBe("auto");
+    expect(mapNeutralToolChoice({ type: "any" })).toBe("required");
+    expect(mapNeutralToolChoice({ type: "none" })).toBe("none");
+    expect(mapNeutralToolChoice({ type: "tool", name: "bash" })).toEqual({
+      type: "function",
+      function: { name: "bash" },
+    });
+  });
+
+  // Unmappable input yields undefined so the request omits tool_choice.
+  test("returns undefined for absent or unrecognized values", () => {
+    // GIVEN values that don't describe a valid tool_choice
+    // WHEN they are mapped
+    // THEN the mapper returns undefined (request falls back to the API default)
+    expect(mapNeutralToolChoice(undefined)).toBeUndefined();
+    expect(mapNeutralToolChoice(null)).toBeUndefined();
+    expect(mapNeutralToolChoice("none")).toBeUndefined();
+    expect(mapNeutralToolChoice({ type: "bogus" })).toBeUndefined();
+    // AND a forced tool with no name can't be expressed
+    expect(mapNeutralToolChoice({ type: "tool" })).toBeUndefined();
+  });
+});
+
+describe("mapNeutralToolChoiceForResponses (Responses API wire format)", () => {
+  // The Responses API named shape omits the chat-completions function wrapper.
+  test("uses the un-nested named-function shape", () => {
+    // GIVEN the neutral tool_choice union
+    // WHEN mapped to the Responses API format
+    // THEN string variants match and the named shape has no `function` wrapper
+    expect(mapNeutralToolChoiceForResponses({ type: "auto" })).toBe("auto");
+    expect(mapNeutralToolChoiceForResponses({ type: "any" })).toBe("required");
+    expect(mapNeutralToolChoiceForResponses({ type: "none" })).toBe("none");
+    expect(
+      mapNeutralToolChoiceForResponses({ type: "tool", name: "bash" }),
+    ).toEqual({ type: "function", name: "bash" });
+    expect(mapNeutralToolChoiceForResponses({ type: "bogus" })).toBeUndefined();
+  });
+});
+
+describe("OpenAIChatCompletionsProvider tool_choice wiring", () => {
+  // A `{ type: "none" }` config forces a text-only answer on the wire.
+  test("forwards config.tool_choice on the wire when tools are present", async () => {
+    // GIVEN a provider with a stubbed SDK client
+    const { provider, requests } = stubChatProvider();
+
+    // WHEN sendMessage is called with tools and tool_choice `{ type: "none" }`
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "none" } },
+    });
+
+    // THEN the outgoing request carries `tool_choice: "none"`
+    expect(requests).toHaveLength(1);
+    expect(requests[0].tool_choice).toBe("none");
+    expect(requests[0].tools).toBeDefined();
+  });
+
+  // A `{ type: "tool", name }` config forces that specific tool call.
+  test("maps a forced tool choice to the named-function wire shape", async () => {
+    // GIVEN a provider with a stubbed SDK client
+    const { provider, requests } = stubChatProvider();
+
+    // WHEN sendMessage is called with a forced tool choice
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "tool", name: "bash" } },
+    });
+
+    // THEN the request carries the OpenAI named-function shape
+    expect(requests[0].tool_choice).toEqual({
+      type: "function",
+      function: { name: "bash" },
+    });
+  });
+
+  // tool_choice is only meaningful alongside tools, so it is dropped.
+  test("omits tool_choice when no tools are supplied", async () => {
+    // GIVEN a provider with a stubbed SDK client
+    const { provider, requests } = stubChatProvider();
+
+    // WHEN sendMessage is called with a tool_choice but no tools
+    await provider.sendMessage(USER_MESSAGE, {
+      config: { tool_choice: { type: "none" } },
+    });
+
+    // THEN the request omits both tools and tool_choice
+    expect(requests[0].tools).toBeUndefined();
+    expect(requests[0].tool_choice).toBeUndefined();
+  });
+});

package/src/providers/openai/chat-completions-provider.ts

@@ -237,6 +237,43 @@ export function clampReasoningEffort(
     : value;
 }
 
+/**
+ * Translate the neutral (Anthropic-shaped) `tool_choice` carried on the call
+ * config into the OpenAI chat-completions wire format. Callers express
+ * `tool_choice` once in the Anthropic union — `{ type: "auto" | "any" | "none"
+ * | "tool", name? }` — and each provider maps it to its own dialect (the
+ * Anthropic client forwards the union verbatim). For OpenAI-compatible APIs:
+ *   - `{ type: "auto" }`        -> `"auto"`
+ *   - `{ type: "any" }`         -> `"required"`
+ *   - `{ type: "none" }`        -> `"none"`
+ *   - `{ type: "tool", name }`  -> `{ type: "function", function: { name } }`
+ * Returns `undefined` for an absent or unrecognized value so the request omits
+ * `tool_choice` and falls back to the API default.
+ *
+ * See OpenAI's tool_choice spec:
+ * https://platform.openai.com/docs/api-reference/chat/create#chat-create-tool_choice
+ */
+export function mapNeutralToolChoice(
+  toolChoice: unknown,
+): OpenAI.Chat.Completions.ChatCompletionToolChoiceOption | undefined {
+  if (toolChoice == null || typeof toolChoice !== "object") return undefined;
+  const tc = toolChoice as { type?: unknown; name?: unknown };
+  switch (tc.type) {
+    case "auto":
+      return "auto";
+    case "any":
+      return "required";
+    case "none":
+      return "none";
+    case "tool":
+      return typeof tc.name === "string"
+        ? { type: "function", function: { name: tc.name } }
+        : undefined;
+    default:
+      return undefined;
+  }
+}
+
 const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
   "image/jpeg",
   "image/png",
@@ -367,6 +404,15 @@ export class OpenAIChatCompletionsProvider implements Provider {
             parameters: t.input_schema as OpenAI.FunctionParameters,
           },
         }));
+
+        // Honor a caller-supplied tool_choice (e.g. `{ type: "none" }` to force
+        // a text-only answer, or `{ type: "tool", name }` for a forced call).
+        // Only meaningful when tools are present — OpenAI rejects a named or
+        // "required" choice with no tools.
+        const toolChoice = mapNeutralToolChoice(configObj?.tool_choice);
+        if (toolChoice !== undefined) {
+          params.tool_choice = toolChoice;
+        }
       }
 
       const { signal: timeoutSignal, cleanup: cleanupTimeout } =

package/src/providers/openai/responses-provider.ts

@@ -49,6 +49,41 @@ const EFFORT_TO_REASONING_EFFORT: Record<
 /** Values accepted by the Responses API `text.verbosity` parameter. */
 const VALID_VERBOSITIES = new Set<string>(["low", "medium", "high"]);
 
+/**
+ * Translate the neutral (Anthropic-shaped) `tool_choice` carried on the call
+ * config into the OpenAI Responses API wire format. Callers express
+ * `tool_choice` once in the Anthropic union — `{ type: "auto" | "any" | "none"
+ * | "tool", name? }`. For the Responses API:
+ *   - `{ type: "auto" }`        -> `"auto"`
+ *   - `{ type: "any" }`         -> `"required"`
+ *   - `{ type: "none" }`        -> `"none"`
+ *   - `{ type: "tool", name }`  -> `{ type: "function", name }`
+ * Note the named shape differs from chat-completions (no nested `function`
+ * wrapper). Returns `undefined` for an absent or unrecognized value.
+ *
+ * https://platform.openai.com/docs/api-reference/responses/create#responses-create-tool_choice
+ */
+export function mapNeutralToolChoiceForResponses(
+  toolChoice: unknown,
+): string | { type: "function"; name: string } | undefined {
+  if (toolChoice == null || typeof toolChoice !== "object") return undefined;
+  const tc = toolChoice as { type?: unknown; name?: unknown };
+  switch (tc.type) {
+    case "auto":
+      return "auto";
+    case "any":
+      return "required";
+    case "none":
+      return "none";
+    case "tool":
+      return typeof tc.name === "string"
+        ? { type: "function", name: tc.name }
+        : undefined;
+    default:
+      return undefined;
+  }
+}
+
 /** `text.verbosity` is a GPT-5-series-only parameter. Older models on the
  *  Responses API (o-series, etc.) reject unknown wire fields with HTTP 400, so
  *  gate forwarding by model name here. The retry layer can't make this call
@@ -229,6 +264,16 @@ export class OpenAIResponsesProvider implements Provider {
             strict: null,
           }));
         }
+
+        // Honor a caller-supplied tool_choice (e.g. `{ type: "none" }` to force
+        // a text-only answer, or `{ type: "tool", name }` for a forced call).
+        // Only meaningful when tools are present.
+        const toolChoice = mapNeutralToolChoiceForResponses(
+          configObj?.tool_choice,
+        );
+        if (toolChoice !== undefined) {
+          params.tool_choice = toolChoice;
+        }
       }
 
       const { signal: timeoutSignal, cleanup: cleanupTimeout } =

package/src/providers/registry.ts

@@ -28,7 +28,6 @@ const log = getLogger("provider-registry");
 
 const providers = new Map<string, Provider>();
 const routingSources = new Map<string, "user-key" | "managed-proxy">();
-const OPENAI_COMPATIBLE_ENDPOINTS_FLAG = "openai-compatible-endpoints";
 const NATIVE_WEB_SEARCH_PROVIDER_IDS = new Set(["anthropic", "openai"]);
 
 /** Per-connection provider cache, keyed by connection name and model. */
@@ -258,13 +257,6 @@ export async function resolveProviderFromConnection(
   config: ProvidersConfig,
   opts: { model?: string } = {},
 ): Promise<Provider | null> {
-  if (
-    connection.provider === "openai-compatible" &&
-    !isProviderFeatureFlagEnabled(OPENAI_COMPATIBLE_ENDPOINTS_FLAG, config)
-  ) {
-    return null;
-  }
-
   const model = opts.model ?? resolveModel(config, connection.provider);
   const cacheKey = getConnectionProviderCacheKey(connection, model);
   const cached = connectionProviders.get(cacheKey);

package/src/runtime/__tests__/agent-wake.test.ts

@@ -249,7 +249,6 @@ import {
 const runResult = (history: Message[]): AgentLoopRunResult => ({
   history,
   exitReason: null,
-  appendedNewMessages: true,
   // The wake path slices its own new-message boundary off the returned
   // history (it never destructures `newMessages`), so this is type-only.
   newMessages: [],

package/src/runtime/agent-wake.ts

@@ -63,6 +63,10 @@ import {
   persistWakeTailMessage,
   scopeWakeAllowedTools,
 } from "../daemon/wake-conversation-ops.js";
+import {
+  recordCompactionEndBestEffort,
+  recordCompactionStartBestEffort,
+} from "../memory/compaction-log-writer-clickhouse.js";
 import { getConversationOverrideProfile } from "../memory/conversation-crud.js";
 import {
   buildProviderErrorResponsePayload,
@@ -598,6 +602,15 @@ export async function wakeAgentForOpportunity(
       }
     };
     const onEvent = (event: AgentEvent): void => {
+      // Compaction logging is observability, not turn state, so it writes
+      // immediately even while buffering — a compaction during a silent
+      // (never-goes-live) wake still happened and should be recorded.
+      if (event.type === "context_compacting") {
+        recordCompactionStartBestEffort(conversationId, event);
+      }
+      if (event.type === "compaction_completed") {
+        recordCompactionEndBestEffort(conversationId, event);
+      }
       // Replicates the recordRequestLog side-effect in `handleUsage` because
       // wakes own their own onEvent and never reach `dispatchAgentEvent`.
       // Defer persistence while buffering — see `pendingLogs` above.

package/src/runtime/routes/__tests__/acp-routes.test.ts

@@ -75,6 +75,7 @@ const steerOrResumeMock = mock(
 mock.module("../../../acp/index.js", () => ({
   getAcpSessionManager: () => ({
     getStatus: () => fakeInMemorySessions,
+    getActiveAndPendingIds: () => fakeInMemorySessions.map((s) => s.id),
     spawn: spawnMock,
     steerOrResume: steerOrResumeMock,
   }),
@@ -86,6 +87,34 @@ mock.module("../../../acp/prepare-agent-env.js", () => ({
   prepareAgentEnv: async (agentConfig: unknown) => agentConfig,
 }));
 
+// The spawn route and steer's resume branch gate on a high-risk approval
+// (ATL-822) before starting the host agent. These tests pin the
+// resolve/install/resume flow, so the hub mock auto-resolves the freshly
+// registered confirmation the same way `POST /v1/confirm` would (resolve +
+// directResolve). `approvalBehavior` flips allow/deny; `confirmationRequests`
+// captures the prompts. Other event types are ignored.
+import * as pendingInteractions from "../../../runtime/pending-interactions.js";
+
+let approvalBehavior: "allow" | "deny" = "allow";
+const confirmationRequests: Array<Record<string, unknown>> = [];
+const broadcasts: Array<Record<string, unknown>> = [];
+
+mock.module("../../../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: { type?: string; requestId?: string }) => {
+    broadcasts.push(msg as Record<string, unknown>);
+    if (msg?.type !== "confirmation_request") return;
+    confirmationRequests.push(msg as Record<string, unknown>);
+    const interaction = pendingInteractions.resolve(
+      msg.requestId as string,
+      approvalBehavior === "allow" ? "approved" : "rejected",
+    );
+    interaction?.directResolve?.(approvalBehavior);
+  },
+}));
+
+/** Drain pending micro/macrotasks so background resume work settles. */
+const flushAsync = () => new Promise((resolve) => setTimeout(resolve, 0));
+
 const config = await installAcpConfigStub();
 const which = installWhichStub();
 
@@ -143,6 +172,9 @@ beforeEach(() => {
   _resetAdapterInstallCacheForTests();
   config.setConfig({});
   which.setWhich((cmd) => `/usr/local/bin/${cmd}`);
+  approvalBehavior = "allow";
+  confirmationRequests.length = 0;
+  broadcasts.length = 0;
 });
 
 describe("GET /v1/acp/sessions — merged in-memory + history", () => {
@@ -652,3 +684,122 @@ describe("POST /v1/acp/:id/steer: resume fallback", () => {
     await expect(promise).rejects.toBeInstanceOf(NotFoundError);
   });
 });
+
+// ---------------------------------------------------------------------------
+// POST /v1/acp/:id/steer: resume crosses the host-spawn boundary, so it is
+// gated by the same high-risk guardian approval as spawn (ATL-822). Steering
+// a session still active in memory only redirects an already-approved live
+// process and is NOT prompted.
+// ---------------------------------------------------------------------------
+
+describe("POST /v1/acp/:id/steer: resume approval gate", () => {
+  test("acks immediately with approvalPending, then resumes once granted", async () => {
+    insertHistoryRow({
+      id: "gone-1",
+      agentId: "claude",
+      parentConversationId: "conv-z",
+      status: "completed",
+      cwd: "/work/repo",
+    });
+    steerOrResumeImpl = async () => ({ resumed: true });
+
+    const handler = getSteerHandler();
+    // The ack returns before the (async) resume completes, so a slow guardian
+    // approval can't trip the client's short ack timeout (ATL-822 / Codex P2).
+    const body = await handler({
+      pathParams: { id: "gone-1" },
+      body: { instruction: "keep going" },
+    });
+    expect(body).toEqual({
+      acpSessionId: "gone-1",
+      steered: false,
+      approvalPending: true,
+    });
+
+    // The high-risk prompt is surfaced for the resume.
+    expect(confirmationRequests).toHaveLength(1);
+    const prompt = confirmationRequests[0];
+    expect(prompt.toolName).toBe("acp_steer");
+    expect(prompt.riskLevel).toBe("high");
+    expect(prompt.executionTarget).toBe("host");
+    expect(prompt.conversationId).toBe("conv-z");
+    expect((prompt.input as { cwd?: string }).cwd).toBe("/work/repo");
+
+    // After approval settles, the background worker performs the resume.
+    await flushAsync();
+    expect(steerOrResumeMock).toHaveBeenCalledTimes(1);
+    expect(steerOrResumeMock.mock.calls[0][0]).toBe("gone-1");
+  });
+
+  test("denied resume never reaches the session manager and reports an error event", async () => {
+    approvalBehavior = "deny";
+    insertHistoryRow({
+      id: "gone-2",
+      acpSessionId: "proto-gone-2",
+      parentConversationId: "conv-z",
+      status: "completed",
+      cwd: "/work/repo",
+    });
+
+    const handler = getSteerHandler();
+    const body = await handler({
+      pathParams: { id: "gone-2" },
+      body: { instruction: "do evil" },
+    });
+    expect(body).toEqual({
+      acpSessionId: "gone-2",
+      steered: false,
+      approvalPending: true,
+    });
+
+    await flushAsync();
+    // Denied before any host re-spawn, and the denial surfaces over SSE.
+    expect(steerOrResumeMock).not.toHaveBeenCalled();
+    expect(pendingInteractions.getAll()).toHaveLength(0);
+    // Keyed by the daemon/route id (what SSE consumers index by), not the
+    // persisted protocol id.
+    const errEvent = broadcasts.find((m) => m.type === "acp_session_error");
+    expect(errEvent?.acpSessionId).toBe("gone-2");
+  });
+
+  test("a legacy row without a persisted cwd is not resumable, so no prompt", async () => {
+    insertHistoryRow({ id: "legacy-2", status: "completed", cwd: null });
+    steerOrResumeImpl = async (id) => {
+      throw new AcpResumeError(
+        new Error(`ACP session "${id}" cannot be resumed.`),
+      );
+    };
+
+    const handler = getSteerHandler();
+    await expect(
+      handler({ pathParams: { id: "legacy-2" }, body: { instruction: "go" } }),
+    ).rejects.toBeInstanceOf(FailedDependencyError);
+    // No spawn would occur, so the gate stays out of the way.
+    expect(confirmationRequests).toHaveLength(0);
+  });
+
+  test("steering a session active in memory is not prompted", async () => {
+    fakeInMemorySessions = [
+      {
+        id: "live-2",
+        agentId: "claude",
+        acpSessionId: "proto-live-2",
+        parentConversationId: "conv-1",
+        status: "running",
+        startedAt: 1000,
+      },
+    ];
+    // A resumable row also exists, but the in-memory session wins → steer.
+    insertHistoryRow({ id: "live-2", status: "completed", cwd: "/work/repo" });
+
+    const handler = getSteerHandler();
+    const body = await handler({
+      pathParams: { id: "live-2" },
+      body: { instruction: "redirect" },
+    });
+
+    expect(confirmationRequests).toHaveLength(0);
+    expect(body).toEqual({ acpSessionId: "live-2", steered: true });
+    expect(steerOrResumeMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/runtime/routes/__tests__/consolidation-routes.test.ts

@@ -24,7 +24,7 @@
  *     once assistant output exists.
  */
 
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -40,7 +40,6 @@ import { invalidateConfigCache } from "../../../config/loader.js";
 import { createConversation } from "../../../memory/conversation-crud.js";
 import { getDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
-import { enqueueMemoryJob } from "../../../memory/jobs-store.js";
 import { recordUsageEvent } from "../../../memory/llm-usage-store.js";
 import { rawAll, rawRun } from "../../../memory/raw-query.js";
 import { ROUTES } from "../consolidation-routes.js";
@@ -112,10 +111,6 @@ function recordUsageCostAt(
   );
 }
 
-function readConfig(): Record<string, unknown> {
-  return JSON.parse(readFileSync(configPath, "utf-8"));
-}
-
 function readMemoryJobRows(): Array<{
   id: string;
   status: string;
@@ -379,7 +374,7 @@ describe("listConsolidationRuns handler", () => {
   });
 });
 
-describe("updateConsolidationConfig handler", () => {
+describe("consolidation config and run-now handlers", () => {
   beforeEach(() => {
     workspaceDir = mkdtempSync(join(tmpdir(), "vellum-consolidation-routes-"));
     origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
@@ -399,12 +394,13 @@ describe("updateConsolidationConfig handler", () => {
     rmSync(workspaceDir, { recursive: true, force: true });
   });
 
-  test("persists only the consolidation enabled override without disabling memory v2", async () => {
+  test("reports consolidation unavailable when global memory is disabled", async () => {
     writeFileSync(
       configPath,
       JSON.stringify(
         {
           memory: {
+            enabled: false,
             v2: {
               enabled: true,
               consolidation_interval_hours: 4,
@@ -416,8 +412,8 @@ describe("updateConsolidationConfig handler", () => {
       ) + "\n",
     );
 
-    const handler = findHandler("updateConsolidationConfig");
-    const result = (await handler({ body: { enabled: false } })) as {
+    const handler = findHandler("getConsolidationConfig");
+    const result = (await handler({})) as {
       available: boolean;
       enabled: boolean;
       intervalMs: number;
@@ -425,17 +421,8 @@ describe("updateConsolidationConfig handler", () => {
       success: boolean;
     };
 
-    expect(readConfig()).toEqual({
-      memory: {
-        v2: {
-          enabled: true,
-          consolidation_interval_hours: 4,
-          consolidation_enabled: false,
-        },
-      },
-    });
     expect(result).toMatchObject({
-      available: true,
+      available: false,
       enabled: false,
       intervalMs: 4 * 60 * 60 * 1000,
       nextRunAt: null,
@@ -443,15 +430,15 @@ describe("updateConsolidationConfig handler", () => {
     });
   });
 
-  test("disabling automatic consolidation cancels pending automatic jobs but preserves manual run-now jobs", async () => {
+  test("run-now is unavailable when global memory is disabled", async () => {
     writeFileSync(
       configPath,
       JSON.stringify(
         {
           memory: {
+            enabled: false,
             v2: {
               enabled: true,
-              consolidation_enabled: true,
             },
           },
         },
@@ -459,36 +446,12 @@ describe("updateConsolidationConfig handler", () => {
         2,
       ) + "\n",
     );
-    const automaticJobId = enqueueMemoryJob("memory_v2_consolidate", {
-      trigger: "automatic",
-    });
-    const legacyJobId = enqueueMemoryJob("memory_v2_consolidate", {});
-    const manualJobId = enqueueMemoryJob("memory_v2_consolidate", {
-      trigger: "manual",
-    });
 
-    const handler = findHandler("updateConsolidationConfig");
-    await handler({ body: { enabled: false } });
-
-    const rowsById = new Map(
-      readMemoryJobRows().map((row) => [row.id, row] as const),
-    );
-    expect(rowsById.get(automaticJobId)).toMatchObject({
-      status: "failed",
-      lastError: "automatic_consolidation_disabled",
-    });
-    expect(rowsById.get(legacyJobId)).toMatchObject({
-      status: "failed",
-      lastError: "automatic_consolidation_disabled",
-    });
-    expect(rowsById.get(manualJobId)).toMatchObject({
-      status: "pending",
-      lastError: null,
-      payload: JSON.stringify({ trigger: "manual" }),
-    });
+    const handler = findHandler("runConsolidationNow");
+    await expect(handler({})).rejects.toThrow("Consolidation is not available");
   });
 
-  test("run-now remains available when automatic consolidation is disabled", async () => {
+  test("run-now remains available when memory v2 is enabled", async () => {
     writeFileSync(
       configPath,
       JSON.stringify(
@@ -496,7 +459,6 @@ describe("updateConsolidationConfig handler", () => {
           memory: {
             v2: {
               enabled: true,
-              consolidation_enabled: false,
             },
           },
         },