@vellumai/assistant 0.6.2 → 0.6.3

package/src/__tests__/channel-approvals.test.ts

@@ -9,6 +9,7 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { Conversation } from "../daemon/conversation.js";
 import * as trustStore from "../permissions/trust-store.js";
 import type {
@@ -81,6 +82,7 @@ function registerPendingConfirmation(
 
 describe("getChannelApprovalPrompt", () => {
   beforeEach(() => {
+    _setOverridesForTesting({});
     pendingInteractions.clear();
   });
 
@@ -169,6 +171,20 @@ describe("getChannelApprovalPrompt", () => {
     const result = getChannelApprovalPrompt("conv-2");
     expect(result).toBeNull();
   });
+
+  test("returns approve_once + reject only under v2", () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+    registerPendingConfirmation("req-v2", "conv-1", "shell");
+
+    const result = getChannelApprovalPrompt("conv-1");
+    expect(result).not.toBeNull();
+    expect(result!.actions.map((a) => a.id)).toEqual([
+      "approve_once",
+      "reject",
+    ]);
+    expect(result!.plainTextFallback).not.toContain("10 minutes");
+    expect(result!.plainTextFallback).not.toContain("always");
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -241,6 +257,7 @@ describe("buildApprovalUIMetadata", () => {
 
 describe("handleChannelDecision", () => {
   beforeEach(() => {
+    _setOverridesForTesting({});
     pendingInteractions.clear();
   });
 
@@ -414,6 +431,24 @@ describe("handleChannelDecision", () => {
 
     addRuleSpy.mockRestore();
   });
+
+  test("v2 collapses legacy approval actions to one-time allow without persisting rules", () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+    registerPendingConfirmation("req-v2", "conv-1", "shell");
+
+    const addRuleSpy = spyOn(trustStore, "addRule");
+    const result = handleChannelDecision("conv-1", {
+      action: "approve_always",
+      requestId: "req-v2",
+      source: "plain_text",
+    });
+
+    expect(result).toEqual({
+      applied: true,
+      requestId: "req-v2",
+    });
+    expect(addRuleSpy).not.toHaveBeenCalled();
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -421,6 +456,10 @@ describe("handleChannelDecision", () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe("buildGuardianApprovalPrompt", () => {
+  beforeEach(() => {
+    _setOverridesForTesting({});
+  });
+
   test("prompt includes requester identifier and tool name", () => {
     const approvalInfo: PendingApprovalInfo = {
       requestId: "req-g1",
@@ -457,6 +496,20 @@ describe("buildGuardianApprovalPrompt", () => {
     expect(prompt.plainTextFallback).toContain("yes");
     expect(prompt.plainTextFallback).toContain("no");
   });
+
+  test("uses approve_once + reject only under v2", () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+    const approvalInfo: PendingApprovalInfo = {
+      requestId: "req-g4",
+      toolName: "shell",
+      input: {},
+      riskLevel: "medium",
+      persistentDecisionsAllowed: true,
+    };
+
+    const prompt = buildGuardianApprovalPrompt(approvalInfo, "dana");
+    expect(prompt.actions.map((a) => a.id)).toEqual(["approve_once", "reject"]);
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════════

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,
     });
   });