@vellumai/assistant 0.6.1 → 0.6.3

package/src/__tests__/config-managed-gemini-defaults.test.ts

@@ -0,0 +1,326 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — declared before imports that depend on platform/logger
+// ---------------------------------------------------------------------------
+
+const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+function ensureTestDir(): void {
+  const dirs = [
+    WORKSPACE_DIR,
+    join(WORKSPACE_DIR, "data"),
+    join(WORKSPACE_DIR, "data", "memory"),
+    join(WORKSPACE_DIR, "data", "memory", "knowledge"),
+    join(WORKSPACE_DIR, "data", "logs"),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+}
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+// ---------------------------------------------------------------------------
+// Feature flag mock — controls whether managed-gemini-embeddings-enabled is on
+// ---------------------------------------------------------------------------
+
+let featureFlagEnabled = false;
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) => {
+    if (key === "managed-gemini-embeddings-enabled") return featureFlagEnabled;
+    return true;
+  },
+  _setOverridesForTesting: () => {},
+  clearFeatureFlagOverridesCache: () => {},
+  initFeatureFlagOverrides: async () => {},
+  getAssistantFeatureFlagDefaults: () => ({}),
+}));
+
+// Restore all mocked modules after this file's tests complete to prevent
+// cross-test contamination when running grouped with other test files.
+afterAll(() => {
+  mock.restore();
+});
+
+import { invalidateConfigCache, loadConfig } from "../config/loader.js";
+import { _setStorePath } from "../security/encrypted-store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function writeConfig(obj: unknown): void {
+  writeFileSync(CONFIG_PATH, JSON.stringify(obj, null, 2) + "\n");
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+}
+
+/** Stash and restore IS_PLATFORM across each test. */
+let originalIsPlatform: string | undefined;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("managed Gemini embedding defaults (via loadConfig)", () => {
+  beforeEach(() => {
+    ensureTestDir();
+    const resetPaths = [
+      CONFIG_PATH,
+      join(WORKSPACE_DIR, "keys.enc"),
+      join(WORKSPACE_DIR, "data"),
+      join(WORKSPACE_DIR, "data", "memory"),
+    ];
+    for (const path of resetPaths) {
+      if (existsSync(path)) {
+        rmSync(path, { recursive: true, force: true });
+      }
+    }
+    ensureTestDir();
+    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    invalidateConfigCache();
+
+    // Reset mock state
+    featureFlagEnabled = false;
+    originalIsPlatform = process.env.IS_PLATFORM;
+    delete process.env.IS_PLATFORM;
+  });
+
+  afterEach(() => {
+    _setStorePath(null);
+    invalidateConfigCache();
+
+    // Restore IS_PLATFORM
+    if (originalIsPlatform !== undefined) {
+      process.env.IS_PLATFORM = originalIsPlatform;
+    } else {
+      delete process.env.IS_PLATFORM;
+    }
+  });
+
+  test("applies managed Gemini defaults when FF on + IS_PLATFORM + provider auto", () => {
+    writeConfig({});
+
+    featureFlagEnabled = true;
+    process.env.IS_PLATFORM = "true";
+
+    const config = loadConfig();
+
+    // In-memory config should have managed Gemini defaults
+    expect(config.memory.embeddings.provider).toBe("gemini");
+    expect(config.memory.embeddings.geminiModel).toBe(
+      "gemini-embedding-2-preview",
+    );
+    expect(config.memory.embeddings.geminiDimensions).toBe(3072);
+    expect(config.memory.qdrant.vectorSize).toBe(3072);
+
+    // Config file on disk should also be updated
+    const raw = readConfig();
+    const memoryRaw = raw.memory as Record<string, unknown>;
+    const embeddingsRaw = memoryRaw.embeddings as Record<string, unknown>;
+    const qdrantRaw = memoryRaw.qdrant as Record<string, unknown>;
+    expect(embeddingsRaw.provider).toBe("gemini");
+    expect(embeddingsRaw.geminiModel).toBe("gemini-embedding-2-preview");
+    expect(embeddingsRaw.geminiDimensions).toBe(3072);
+    expect(qdrantRaw.vectorSize).toBe(3072);
+  });
+
+  test("does NOT apply when feature flag is OFF", () => {
+    writeConfig({});
+
+    featureFlagEnabled = false;
+    process.env.IS_PLATFORM = "true";
+
+    const config = loadConfig();
+
+    expect(config.memory.embeddings.provider).toBe("auto");
+    expect(config.memory.qdrant.vectorSize).toBe(384);
+  });
+
+  test("does NOT apply when IS_PLATFORM is not set", () => {
+    writeConfig({});
+
+    featureFlagEnabled = true;
+    delete process.env.IS_PLATFORM;
+
+    const config = loadConfig();
+
+    expect(config.memory.embeddings.provider).toBe("auto");
+    expect(config.memory.qdrant.vectorSize).toBe(384);
+  });
+
+  test("does NOT apply when provider is explicitly set to local", () => {
+    writeConfig({
+      memory: { embeddings: { provider: "local" } },
+    });
+
+    featureFlagEnabled = true;
+    process.env.IS_PLATFORM = "true";
+
+    const config = loadConfig();
+    expect(config.memory.embeddings.provider).toBe("local");
+    expect(config.memory.qdrant.vectorSize).toBe(384);
+  });
+
+  test("does NOT apply when provider is explicitly set to openai", () => {
+    writeConfig({
+      memory: { embeddings: { provider: "openai" } },
+    });
+
+    featureFlagEnabled = true;
+    process.env.IS_PLATFORM = "true";
+
+    const config = loadConfig();
+    expect(config.memory.embeddings.provider).toBe("openai");
+  });
+
+  test("does NOT apply when provider is explicitly set to gemini", () => {
+    writeConfig({
+      memory: {
+        embeddings: { provider: "gemini", geminiDimensions: 768 },
+        qdrant: { vectorSize: 768 },
+      },
+    });
+
+    featureFlagEnabled = true;
+    process.env.IS_PLATFORM = "true";
+
+    const config = loadConfig();
+
+    // Already gemini — should not overwrite user's custom dimensions
+    expect(config.memory.embeddings.provider).toBe("gemini");
+    expect(config.memory.embeddings.geminiDimensions).toBe(768);
+    expect(config.memory.qdrant.vectorSize).toBe(768);
+  });
+
+  test("does NOT apply when provider is explicitly set to ollama", () => {
+    writeConfig({
+      memory: { embeddings: { provider: "ollama" } },
+    });
+
+    featureFlagEnabled = true;
+    process.env.IS_PLATFORM = "true";
+
+    const config = loadConfig();
+    expect(config.memory.embeddings.provider).toBe("ollama");
+  });
+
+  test("is idempotent — second loadConfig is a no-op after migration", () => {
+    writeConfig({});
+
+    featureFlagEnabled = true;
+    process.env.IS_PLATFORM = "true";
+
+    const config = loadConfig();
+    expect(config.memory.embeddings.provider).toBe("gemini");
+
+    // Read file content after first migration
+    const contentAfterFirst = readFileSync(CONFIG_PATH, "utf-8");
+
+    // Second call — provider is now "gemini", not "auto", so migration skipped
+    invalidateConfigCache();
+    const config2 = loadConfig();
+    expect(config2.memory.embeddings.provider).toBe("gemini");
+
+    // File on disk should not have changed
+    const contentAfterSecond = readFileSync(CONFIG_PATH, "utf-8");
+    expect(contentAfterSecond).toBe(contentAfterFirst);
+  });
+
+  test("preserves existing config values while setting managed defaults", () => {
+    writeConfig({
+      provider: "anthropic",
+      model: "claude-opus-4-6",
+      memory: {
+        enabled: true,
+        qdrant: { collection: "my-collection", onDisk: false },
+      },
+    });
+
+    featureFlagEnabled = true;
+    process.env.IS_PLATFORM = "true";
+
+    const config = loadConfig();
+
+    // Managed defaults applied
+    expect(config.memory.embeddings.provider).toBe("gemini");
+    expect(config.memory.embeddings.geminiModel).toBe(
+      "gemini-embedding-2-preview",
+    );
+    expect(config.memory.qdrant.vectorSize).toBe(3072);
+
+    // Existing values preserved
+    const raw = readConfig();
+    expect(raw.provider).toBe("anthropic");
+    expect(raw.model).toBe("claude-opus-4-6");
+    const memoryRaw = raw.memory as Record<string, unknown>;
+    expect(memoryRaw.enabled).toBe(true);
+    const qdrantRaw = memoryRaw.qdrant as Record<string, unknown>;
+    expect(qdrantRaw.collection).toBe("my-collection");
+    expect(qdrantRaw.onDisk).toBe(false);
+  });
+
+  test("does NOT apply when both FF off and IS_PLATFORM not set", () => {
+    writeConfig({});
+
+    featureFlagEnabled = false;
+    delete process.env.IS_PLATFORM;
+
+    const config = loadConfig();
+
+    expect(config.memory.embeddings.provider).toBe("auto");
+    expect(config.memory.qdrant.vectorSize).toBe(384);
+  });
+
+  test("applies when IS_PLATFORM is '1'", () => {
+    writeConfig({});
+
+    featureFlagEnabled = true;
+    process.env.IS_PLATFORM = "1";
+
+    const config = loadConfig();
+
+    expect(config.memory.embeddings.provider).toBe("gemini");
+    expect(config.memory.embeddings.geminiDimensions).toBe(3072);
+  });
+});

package/src/__tests__/config-schema-cmd.test.ts

@@ -87,7 +87,7 @@ describe("getSchemaAtPath", () => {
     expect(result).not.toBeNull();
     // maxTokens has a default, so it should be parseable
     const parsed = (result as z.ZodType).parse(undefined);
-    expect(parsed).toBe(16000);
+    expect(parsed).toBe(64000);
   });
 
   test("navigates nested paths (memory.segmentation → object schema)", () => {
@@ -188,7 +188,7 @@ describe("z.toJSONSchema integration", () => {
     expect(properties.calls).toBeDefined();
     expect(properties.memory).toBeDefined();
     expect(properties.timeouts).toBeDefined();
-    expect(properties.sandbox).toBeDefined();
+    expect(properties.permissions).toBeDefined();
   });
 
   test("full schema emits real properties for transformed fields (ingress)", () => {

package/src/__tests__/config-schema.test.ts

@@ -81,7 +81,7 @@ describe("AssistantConfigSchema", () => {
       "inference-provider-native",
     );
     expect(result.services["web-search"].mode).toBe("your-own");
-    expect(result.maxTokens).toBe(16000);
+    expect(result.maxTokens).toBe(64000);
     expect(result.thinking).toEqual({
       enabled: true,
       streamThinking: true,
@@ -107,9 +107,6 @@ describe("AssistantConfigSchema", () => {
       toolExecutionTimeoutSec: 120,
       providerStreamTimeoutSec: 1800,
     });
-    expect(result.sandbox).toEqual({
-      enabled: false,
-    });
     expect(result.rateLimit).toEqual({
       maxRequestsPerMinute: 0,
     });
@@ -169,7 +166,7 @@ describe("AssistantConfigSchema", () => {
       enqueueIntervalMs: 6 * 60 * 60 * 1000,
       supersededItemRetentionMs: 30 * 24 * 60 * 60 * 1000,
       conversationRetentionDays: 0,
-      llmRequestLogRetentionMs: 7 * 24 * 60 * 60 * 1000,
+      llmRequestLogRetentionMs: 1 * 24 * 60 * 60 * 1000,
     });
   });
 
@@ -400,29 +397,10 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("sandbox with only enabled still parses", () => {
-    const result = AssistantConfigSchema.parse({ sandbox: { enabled: false } });
-    expect(result.sandbox.enabled).toBe(false);
-  });
-
-  test("rejects unknown sandbox fields", () => {
-    const result = AssistantConfigSchema.safeParse({
-      sandbox: { backend: "docker" },
-    });
-    // Unknown keys are stripped by Zod passthrough/strip, so parse should still succeed
-    // but the unknown field should not appear in the output
-    if (result.success) {
-      expect(
-        (result.data.sandbox as Record<string, unknown>)["backend"],
-      ).toBeUndefined();
-    }
-  });
-
   test("defaults permissions.mode to workspace", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.permissions).toEqual({
       mode: "workspace",
-      askBeforeActing: true,
       hostAccess: false,
     });
   });
@@ -861,6 +839,125 @@ describe("AssistantConfigSchema", () => {
     });
     expect(result.calls.callerIdentity.allowPerCallOverride).toBe(true);
   });
+
+  // ── hostBrowser.cdpInspect config ─────────────────────────────────
+
+  test("applies hostBrowser.cdpInspect defaults", () => {
+    const result = AssistantConfigSchema.parse({});
+    expect(result.hostBrowser).toEqual({
+      cdpInspect: {
+        enabled: false,
+        host: "localhost",
+        port: 9222,
+        probeTimeoutMs: 500,
+      },
+    });
+  });
+
+  test("accepts hostBrowser.cdpInspect enabled with custom host/port", () => {
+    const result = AssistantConfigSchema.parse({
+      hostBrowser: {
+        cdpInspect: {
+          enabled: true,
+          host: "127.0.0.1",
+          port: 9333,
+        },
+      },
+    });
+    expect(result.hostBrowser.cdpInspect.enabled).toBe(true);
+    expect(result.hostBrowser.cdpInspect.host).toBe("127.0.0.1");
+    expect(result.hostBrowser.cdpInspect.port).toBe(9333);
+    // Unset field should still receive its default.
+    expect(result.hostBrowser.cdpInspect.probeTimeoutMs).toBe(500);
+  });
+
+  test("accepts hostBrowser.cdpInspect custom probeTimeoutMs", () => {
+    const result = AssistantConfigSchema.parse({
+      hostBrowser: { cdpInspect: { probeTimeoutMs: 1000 } },
+    });
+    expect(result.hostBrowser.cdpInspect.probeTimeoutMs).toBe(1000);
+  });
+
+  test("rejects hostBrowser.cdpInspect.port below 1", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { port: 0 } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path.join(".").includes("hostBrowser.cdpInspect.port"),
+        ),
+      ).toBe(true);
+    }
+  });
+
+  test("rejects hostBrowser.cdpInspect.port above 65535", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { port: 70000 } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path.join(".").includes("hostBrowser.cdpInspect.port"),
+        ),
+      ).toBe(true);
+    }
+  });
+
+  test("rejects non-integer hostBrowser.cdpInspect.port", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { port: 9222.5 } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects hostBrowser.cdpInspect.probeTimeoutMs below 50", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { probeTimeoutMs: 10 } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path
+            .join(".")
+            .includes("hostBrowser.cdpInspect.probeTimeoutMs"),
+        ),
+      ).toBe(true);
+    }
+  });
+
+  test("rejects hostBrowser.cdpInspect.probeTimeoutMs above 5000", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { probeTimeoutMs: 10000 } },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(
+        result.error.issues.some((issue) =>
+          issue.path
+            .join(".")
+            .includes("hostBrowser.cdpInspect.probeTimeoutMs"),
+        ),
+      ).toBe(true);
+    }
+  });
+
+  test("rejects non-integer hostBrowser.cdpInspect.probeTimeoutMs", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { probeTimeoutMs: 500.5 } },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects non-boolean hostBrowser.cdpInspect.enabled", () => {
+    const result = AssistantConfigSchema.safeParse({
+      hostBrowser: { cdpInspect: { enabled: "yes" } },
+    });
+    expect(result.success).toBe(false);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -1002,7 +1099,7 @@ describe("loadConfig with schema validation", () => {
     const config = loadConfig();
     expect(config.services.inference.provider).toBe("anthropic");
     expect(config.services.inference.model).toBe("claude-opus-4-6");
-    expect(config.maxTokens).toBe(16000);
+    expect(config.maxTokens).toBe(64000);
     expect(config.thinking).toEqual({
       enabled: true,
       streamThinking: true,
@@ -1034,7 +1131,7 @@ describe("loadConfig with schema validation", () => {
   test("falls back to default for invalid maxTokens", () => {
     writeConfig({ maxTokens: -100 });
     const config = loadConfig();
-    expect(config.maxTokens).toBe(16000);
+    expect(config.maxTokens).toBe(64000);
   });
 
   test("falls back to defaults for invalid nested values", () => {
@@ -1059,13 +1156,13 @@ describe("loadConfig with schema validation", () => {
     expect(config.services.inference.provider).toBe("openai");
     expect(config.services.inference.model).toBe("gpt-4");
     expect(config.thinking.enabled).toBe(true);
-    expect(config.maxTokens).toBe(16000);
+    expect(config.maxTokens).toBe(64000);
   });
 
   test("handles no config file", () => {
     const config = loadConfig();
     expect(config.services.inference.provider).toBe("anthropic");
-    expect(config.maxTokens).toBe(16000);
+    expect(config.maxTokens).toBe(64000);
   });
 
   test("partial nested objects get defaults for missing fields", () => {
@@ -1084,25 +1181,6 @@ describe("loadConfig with schema validation", () => {
     expect(config.secretDetection.action).toBe("redact");
   });
 
-  test("falls back for invalid sandbox.enabled", () => {
-    writeConfig({ sandbox: { enabled: "yes" } });
-    const config = loadConfig();
-    expect(config.sandbox.enabled).toBe(false);
-  });
-
-  test("loads sandbox with only enabled field", () => {
-    writeConfig({ sandbox: { enabled: false } });
-    const config = loadConfig();
-    expect(config.sandbox.enabled).toBe(false);
-  });
-
-  test("strips unknown sandbox fields", () => {
-    writeConfig({ sandbox: { enabled: true, backend: "docker" } });
-    const config = loadConfig();
-    expect(config.sandbox.enabled).toBe(true);
-    expect("backend" in config.sandbox).toBe(false);
-  });
-
   test("falls back for invalid contextWindow relationship", () => {
     writeConfig({
       contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
@@ -1131,7 +1209,6 @@ describe("loadConfig with schema validation", () => {
     const config = loadConfig();
     expect(config.permissions).toEqual({
       mode: "workspace",
-      askBeforeActing: true,
       hostAccess: false,
     });
   });

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -10,6 +10,8 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -133,6 +135,7 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     resetTables();
     emittedSignals.length = 0;
     mockOnConversationCreatedCallbacks.length = 0;
+    _setOverridesForTesting({});
   });
 
   test("emits guardian.question for trusted-contact sessions", () => {
@@ -223,6 +226,26 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
+  test("skips trusted-contact bridging entirely under permission-controls-v2", () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+
+    const canonicalRequest = makeCanonicalRequest();
+    const trustContext = makeTrustedContactContext();
+
+    const result = bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      trustContext,
+      conversationId: "conv-1",
+      toolName: "bash",
+    });
+
+    expect("skipped" in result && result.skipped).toBe(true);
+    if ("skipped" in result) {
+      expect(result.reason).toBe("v2_model_mediated");
+    }
+    expect(emittedSignals).toHaveLength(0);
+  });
+
   test("skips when no guardian binding exists for channel", () => {
     const canonicalRequest = makeCanonicalRequest({ sourceChannel: "phone" });
     const trustContext = makeTrustedContactContext({

package/src/__tests__/context-overflow-approval.test.ts

@@ -1,5 +1,6 @@
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import {
   CONTEXT_OVERFLOW_TOOL_NAME,
   requestCompressionApproval,
@@ -20,8 +21,22 @@ function createMockPrompter(decision: UserDecision): PermissionPrompter {
 }
 
 describe("requestCompressionApproval", () => {
+  beforeEach(() => {
+    _setOverridesForTesting({});
+  });
+
   // ── Prompt shape ──
 
+  test("auto-approves without prompting under v2", async () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+
+    const prompter = createMockPrompter("deny");
+    const result = await requestCompressionApproval(prompter);
+
+    expect(result).toEqual({ approved: true });
+    expect(prompter.prompt).not.toHaveBeenCalled();
+  });
+
   test("uses the reserved pseudo tool name", async () => {
     const prompter = createMockPrompter("allow");
     await requestCompressionApproval(prompter);
@@ -55,8 +70,8 @@ describe("requestCompressionApproval", () => {
     await requestCompressionApproval(prompter);
 
     const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
-    // persistentDecisionsAllowed is index 9
-    expect(args[9]).toBe(false);
+    // persistentDecisionsAllowed is index 8
+    expect(args[8]).toBe(false);
   });
 
   test("includes a description in the input", async () => {
@@ -119,8 +134,8 @@ describe("requestCompressionApproval", () => {
     });
 
     const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
-    // signal is index 10
-    expect(args[10]).toBe(controller.signal);
+    // signal is index 9
+    expect(args[9]).toBe(controller.signal);
   });
 
   test("works without signal option", async () => {
@@ -130,7 +145,7 @@ describe("requestCompressionApproval", () => {
 
     const args = (prompter.prompt as ReturnType<typeof mock>).mock.calls[0];
     // signal should be undefined when not provided
-    expect(args[10]).toBeUndefined();
+    expect(args[9]).toBeUndefined();
   });
 
   // ── Tool name constant ──