@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/__tests__/guardian-card-withdrawal.test.ts

@@ -1,13 +1,5 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 const completeSurfaceAndNotify = mock(() => {});
 mock.module("../daemon/conversation-surfaces.js", () => ({
   completeSurfaceAndNotify,

package/src/__tests__/guardian-decision-primitive-canonical.test.ts

@@ -1,12 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
   applyCanonicalGuardianDecision,

package/src/__tests__/guardian-dispatch.test.ts

@@ -3,13 +3,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 import type { ConversationCreatedInfo } from "../notifications/broadcaster.js";
 import type { NotificationDeliveryResult } from "../notifications/types.js";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // Note: stale mock for channel-guardian-store.js removed — the barrel was
 // deleted and none of the functions it mocked (getActiveBinding, createBinding,
 // listActiveBindingsByAssistant) existed in the barrel.

package/src/__tests__/guardian-expiry-notifier.test.ts

@@ -11,15 +11,6 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// Silence logging.
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 // Capture requester channel deliveries; optionally fail to exercise the
 // best-effort path.
 const deliveredReplies: Array<{
@@ -78,6 +69,7 @@ function makeRequest(
     conversationId: "conv-1",
     requesterExternalUserId: "req-user",
     requesterChatId: "req-chat",
+    trigger: null,
     guardianExternalUserId: "guardian-user",
     guardianPrincipalId: "guardian-principal",
     callSessionId: null,

package/src/__tests__/guardian-outbound-http.test.ts

@@ -18,13 +18,6 @@ import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 // Test isolation: in-memory SQLite via temp directory
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",

package/src/__tests__/guardian-principal-id-roundtrip.test.ts

@@ -1,11 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
   createCanonicalGuardianRequest,

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -43,14 +43,6 @@ mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 import { applyCanonicalGuardianDecision } from "../approvals/guardian-decision-primitive.js";
 import type { ActorContext } from "../approvals/guardian-request-resolvers.js";
 import {

package/src/__tests__/guardian-routing-state.test.ts

@@ -6,15 +6,7 @@ import { eq } from "drizzle-orm";
 // ---------------------------------------------------------------------------
 // Test isolation: in-memory SQLite via temp directory
 // ---------------------------------------------------------------------------
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-import type { TrustContext } from "../daemon/trust-context.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import * as deliveryCrud from "../persistence/delivery-crud.js";

package/src/__tests__/guardian-verification-voice-binding.test.ts

@@ -4,13 +4,6 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../calls/twilio-config.js", () => ({
   getTwilioConfig: () => ({
     accountSid: "AC_test",

package/src/__tests__/handlers-skills-memory-v2-reseed.test.ts

@@ -206,8 +206,6 @@ mock.module("../util/platform.js", () => {
     getProfilerRootDir: stub,
     getProfilerRunsDir: stub,
     getProfilerRunDir: stub,
-    getSkillRuntimePath: stub,
-    getBundledBunPath: () => undefined,
     ensureDataDir: () => {},
   };
 });

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -110,12 +110,11 @@ mock.module("../config/loader.js", () => ({
   API_KEY_PROVIDERS: [],
 }));
 
+const realLocalActorIdentity = await import(
+  "../runtime/local-actor-identity.js"
+);
 mock.module("../runtime/local-actor-identity.js", () => ({
-  resolveLocalTrustContext: () => ({
-    trustClass: "guardian",
-    sourceChannel: "vellum",
-    guardianPrincipalId: "local-principal",
-  }),
+  ...realLocalActorIdentity,
   resolveLocalAuthContext: () => ({
     scope: "local_v1",
     actorPrincipalId: "local-principal",

package/src/__tests__/headless-browser-interactions.test.ts

@@ -2,13 +2,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Mocks ────────────────────────────────────────────────────────────
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 /**
  * Fake CDP session used by every interaction tool that has been
  * migrated to `CdpClient` (click, hover, type, press_key,

package/src/__tests__/headless-browser-mode.test.ts

@@ -1,21 +1,12 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Mocks ────────────────────────────────────────────────────────────
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // ── Fake CdpClient & Factory ─────────────────────────────────────────
 //
 // This test file validates browser_mode parsing and mode-selection
 // failure formatting in browser-execution.ts. The factory mock
 // intercepts getCdpClient calls and can be configured to throw
 // CdpError for pinned-mode precondition failures.
-
 import { CdpError } from "../tools/browser/cdp-client/errors.js";
 import type { AttemptDiagnostic } from "../tools/browser/cdp-client/types.js";
 

package/src/__tests__/headless-browser-navigate.test.ts

@@ -2,13 +2,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Mocks ────────────────────────────────────────────────────────────
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // ── Fake CdpClient ───────────────────────────────────────────────────
 //
 // Programmable send handler + call log shared across tests. Each test
@@ -679,7 +672,7 @@ describe("executeBrowserNavigate", () => {
     expect(cdpDisposed).toBe(true);
   });
 
-  // ── --new-tab flag (extension path only) ──────────────────────
+  // ── tab routing (extension path only) ─────────────────────────
 
   test("extension path with new_tab: true opens a fresh tab and pins it before Page.navigate", async () => {
     parseUrlResult = new URL("https://example.com/page");
@@ -779,9 +772,8 @@ describe("executeBrowserNavigate", () => {
     // follow-on Page.navigate would still route to the dead tab
     // unless we reset the session on the cdp instance too (round-3
     // P1 fix added cdp.setCdpSessionId(undefined)).
-    const { setPinnedTab, getPinnedTab } = await import(
-      "../tools/browser/pinned-tabs.js"
-    );
+    const { setPinnedTab, getPinnedTab } =
+      await import("../tools/browser/pinned-tabs.js");
     setPinnedTab(ctx.conversationId, "stale-pinned-tab-id");
     expect(getPinnedTab(ctx.conversationId)).toBe("stale-pinned-tab-id");
 
@@ -825,20 +817,106 @@ describe("executeBrowserNavigate", () => {
     expect(cdpSetSessionIdCalls).toEqual([]);
   });
 
-  test("absence of new_tab leaves extension path untouched (no Vellum.createTab)", async () => {
+  test("default (no flags) on extension opens a dedicated tab and pins it before Page.navigate", async () => {
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return { tabId: "999" };
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page" }, // no flags — default behavior
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // The dedicated tab is opened BEFORE Page.navigate so the navigation
+    // lands on it rather than the user's active tab.
+    const createIdx = cdpSendCalls.findIndex(
+      (c) => c.method === "Vellum.createTab",
+    );
+    const navIdx = cdpSendCalls.findIndex((c) => c.method === "Page.navigate");
+    expect(createIdx).toBeGreaterThanOrEqual(0);
+    expect(navIdx).toBeGreaterThanOrEqual(0);
+    expect(createIdx).toBeLessThan(navIdx);
+    expect(cdpSetSessionIdCalls).toContain("999");
+  });
+
+  test("default reuses an existing pinned tab (no Vellum.createTab)", async () => {
+    const { setPinnedTab } = await import("../tools/browser/pinned-tabs.js");
+    setPinnedTab(ctx.conversationId, "already-pinned-tab");
+
     parseUrlResult = new URL("https://example.com/page");
     mockExtensionAvailable = true;
 
     const result = await executeBrowserNavigate(
-      { url: "https://example.com/page" }, // no new_tab key at all
+      { url: "https://example.com/page" }, // no flags
       { ...ctx },
     );
 
     expect(result.isError).toBe(false);
+    // Conversation already has a dedicated tab; the `cdp` client was
+    // constructed routed to it, so no new tab is opened and the live
+    // session is left as-is.
     expect(cdpSendCalls.some((c) => c.method === "Vellum.createTab")).toBe(
       false,
     );
     expect(cdpSetSessionIdCalls).toEqual([]);
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
+  });
+
+  test("new_tab: true forces a fresh tab even when one is already pinned", async () => {
+    const { setPinnedTab, getPinnedTab } =
+      await import("../tools/browser/pinned-tabs.js");
+    setPinnedTab(ctx.conversationId, "already-pinned-tab");
+
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") return { tabId: "1001" };
+      return defaultCdpHandler(method, params);
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", new_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // --new-tab overrides the reuse path and opens a brand-new tab,
+    // re-pinning the conversation to it.
+    expect(cdpSendCalls.some((c) => c.method === "Vellum.createTab")).toBe(
+      true,
+    );
+    expect(cdpSetSessionIdCalls).toContain("1001");
+    expect(getPinnedTab(ctx.conversationId)).toBe("1001");
+  });
+
+  test("use_active_tab: true navigates the active tab, clearing any pin and live session", async () => {
+    const { setPinnedTab, getPinnedTab } =
+      await import("../tools/browser/pinned-tabs.js");
+    setPinnedTab(ctx.conversationId, "already-pinned-tab");
+
+    parseUrlResult = new URL("https://example.com/page");
+    mockExtensionAvailable = true;
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com/page", use_active_tab: true },
+      { ...ctx },
+    );
+
+    expect(result.isError).toBe(false);
+    // Opt-out: no dedicated tab is opened; the pin and live session are
+    // cleared so the navigate is authoritative on the active tab.
+    expect(cdpSendCalls.some((c) => c.method === "Vellum.createTab")).toBe(
+      false,
+    );
+    expect(getPinnedTab(ctx.conversationId)).toBeUndefined();
+    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
   });
 
   // ── Defense-in-depth: post-navigation final URL check ─────────

package/src/__tests__/headless-browser-read-tools.test.ts

@@ -2,13 +2,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Mocks ────────────────────────────────────────────────────────────
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 /**
  * Fake CDP session used by the screenshot/extract/wait_for tests in
  * this file. The tests configure `sendHandler` before invoking a

package/src/__tests__/headless-browser-snapshot.test.ts

@@ -2,13 +2,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Mocks ────────────────────────────────────────────────────────────
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 /**
  * Shared fake CDP session state. Tests install a custom `cdpSend`
  * implementation in their setup, then assert against `cdpCalls` and

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -7,15 +7,6 @@ mock.module("../runtime/pre-first-message-gate.js", () => ({
   _resetPreFirstMessageGateCacheForTests: () => {},
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    debug: () => {},
-    warn: () => {},
-    error: () => {},
-  }),
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     heartbeat: {

package/src/__tests__/helpers/set-config.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared test helper: seed workspace config for real instead of mocking
+ * `config/loader`.
+ *
+ * Writes a top-level key into `$VELLUM_WORKSPACE_DIR/config.json`
+ * (read-modify-write, so seeding several keys composes) and bumps the file
+ * mtime monotonically so the loader's file-signature cache re-reads on the
+ * next `getConfig()`/`getConfigReadOnly()`. The production loader
+ * schema-merges the partial file over defaults — the same path a user's
+ * config.json takes.
+ *
+ * Node stdlib only, per the test-machinery isolation rules.
+ */
+import { existsSync, readFileSync, utimesSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+let mtimeSeq = 0;
+
+export function setConfig(key: string, value: unknown): void {
+  const path = join(process.env.VELLUM_WORKSPACE_DIR!, "config.json");
+  let config: Record<string, unknown> = {};
+  if (existsSync(path)) {
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        config = parsed as Record<string, unknown>;
+      }
+    } catch {
+      // Unparseable prior seed — start fresh; the loader treats a corrupt
+      // file as defaults anyway.
+    }
+  }
+  config[key] = value;
+  writeFileSync(path, JSON.stringify(config));
+  // Force a distinct mtime per write so the loader's size+mtime+ctime
+  // signature can never read two consecutive seeds as identical.
+  mtimeSeq += 1;
+  const stamp = new Date(Date.now() + mtimeSeq);
+  utimesSync(path, stamp, stamp);
+}

package/src/__tests__/host-bash-proxy.test.ts

@@ -137,8 +137,8 @@ describe("HostBashProxy", () => {
 
       const resultPromise = proxy.request(
         {
-          command: "echo locked",
-          env: { VELLUM_UNTRUSTED_SHELL: "1" },
+          command: "echo hi",
+          env: { __CONVERSATION_ID: "conv-1" },
         },
         "session-1",
       );
@@ -146,7 +146,7 @@ describe("HostBashProxy", () => {
       expect(sentMessages).toHaveLength(1);
       const sent = sentMessages[0] as Record<string, unknown>;
       expect(sent.type).toBe("host_bash_request");
-      expect(sent.env).toEqual({ VELLUM_UNTRUSTED_SHELL: "1" });
+      expect(sent.env).toEqual({ __CONVERSATION_ID: "conv-1" });
 
       const requestId = sent.requestId as string;
       proxy.resolveResult(requestId, {

package/src/__tests__/host-browser-proxy.test.ts

@@ -2,13 +2,6 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Module mocks ─────────────────────────────────────────────────────
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 /** Events published through the mock event hub. */
 let publishedEvents: unknown[] = [];
 
@@ -35,7 +28,9 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
       // pending-interactions tracker for every resolution. They are
       // orthogonal to the host-browser wire messages these tests assert
       // on, so swallow them here.
-      if ((event as { type?: string } | null)?.type === "interaction_resolved") {
+      if (
+        (event as { type?: string } | null)?.type === "interaction_resolved"
+      ) {
         return;
       }
       publishedEvents.push(event);
@@ -119,16 +114,16 @@ describe("HostBrowserProxy", () => {
 
     test("returns true immediately when an extension is connected", async () => {
       mockClients = [EXTENSION];
-      expect(await proxy.waitForExtensionClient(undefined, undefined, 1_000)).toBe(
-        true,
-      );
+      expect(
+        await proxy.waitForExtensionClient(undefined, undefined, 1_000),
+      ).toBe(true);
     });
 
     test("returns false after the timeout when none connects", async () => {
       mockClients = [DEFAULT_CLIENT]; // macos only, no extension
-      expect(await proxy.waitForExtensionClient(undefined, undefined, 100)).toBe(
-        false,
-      );
+      expect(
+        await proxy.waitForExtensionClient(undefined, undefined, 100),
+      ).toBe(false);
     });
 
     test("returns true when an extension appears within the window", async () => {
@@ -136,9 +131,9 @@ describe("HostBrowserProxy", () => {
       setTimeout(() => {
         mockClients = [DEFAULT_CLIENT, EXTENSION];
       }, 50);
-      expect(await proxy.waitForExtensionClient(undefined, undefined, 2_000)).toBe(
-        true,
-      );
+      expect(
+        await proxy.waitForExtensionClient(undefined, undefined, 2_000),
+      ).toBe(true);
     });
 
     test("respects sourceActorPrincipalId", async () => {
@@ -151,9 +146,9 @@ describe("HostBrowserProxy", () => {
         },
       ];
       // Caller is actor-a; the connected extension belongs to actor-b.
-      expect(await proxy.waitForExtensionClient("actor-a", undefined, 100)).toBe(
-        false,
-      );
+      expect(
+        await proxy.waitForExtensionClient("actor-a", undefined, 100),
+      ).toBe(false);
     });
 
     test("with a targetClientId, waits for that exact client (not a sibling)", async () => {

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -29,7 +29,6 @@ mock.module("../config/env.js", () => ({
   setIngressPublicBaseUrl: () => {},
   getRuntimeHttpPort: () => 3000,
   getRuntimeHttpHost: () => "0.0.0.0",
-  getSentryDsn: () => "",
   getQdrantUrlEnv: () => undefined,
   getQdrantHttpPortEnv: () => undefined,
   getQdrantReadyzTimeoutMs: () => undefined,

package/src/__tests__/host-shell-tool.test.ts

@@ -46,13 +46,6 @@ mock.module("../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // Mock the host-bash-proxy singleton so proxy delegation tests can control it.
 let mockProxyAvailable = false;
 let mockProxyRequestFn: (
@@ -867,50 +860,7 @@ describe("host_bash — proxy delegation", () => {
     expect(spawnCalls.length).toBe(1);
   });
 
-  test("propagates VELLUM_UNTRUSTED_SHELL env to proxy under CES lockdown", async () => {
-    // Enable CES shell lockdown via the override cache
-    const { setOverridesForTesting } =
-      await import("./feature-flag-test-helpers.js");
-    setOverridesForTesting({
-      "ces-shell-lockdown": true,
-    });
-
-    const envSnapshot = captureEnv(ROUTING_ENV_KEYS);
-    // Keep this test focused on lockdown propagation behavior only.
-    for (const key of ROUTING_ENV_KEYS) {
-      delete process.env[key];
-    }
-
-    try {
-      const proxyResult: ToolExecutionResult = {
-        content: "proxied",
-        isError: false,
-      };
-      const calls = setupMockProxy(proxyResult);
-
-      const ctx: ToolContext = {
-        ...makeContext(),
-        trustClass: "trusted_contact", // untrusted actor
-      };
-
-      const result = await hostShellTool.execute(
-        { command: "echo lockdown" },
-        ctx,
-      );
-
-      expect(result).toBe(proxyResult);
-      expect(calls.length).toBe(1);
-      expect(calls[0].input.env).toEqual({
-        VELLUM_UNTRUSTED_SHELL: "1",
-        __CONVERSATION_ID: "test-conversation",
-      });
-    } finally {
-      setOverridesForTesting({});
-      restoreEnv(envSnapshot);
-    }
-  });
-
-  test("does not propagate env to proxy when CES lockdown is inactive", async () => {
+  test("propagates only __CONVERSATION_ID to proxy when no routing env is set", async () => {
     const envSnapshot = captureEnv(ROUTING_ENV_KEYS);
     for (const key of ROUTING_ENV_KEYS) {
       delete process.env[key];
@@ -923,14 +873,9 @@ describe("host_bash — proxy delegation", () => {
       };
       const calls = setupMockProxy(proxyResult);
 
-      const ctx: ToolContext = {
-        ...makeContext(),
-        trustClass: "guardian", // trusted actor — no lockdown
-      };
-
       const result = await hostShellTool.execute(
-        { command: "echo no-lockdown" },
-        ctx,
+        { command: "echo proxied" },
+        makeContext(),
       );
 
       expect(result).toBe(proxyResult);
@@ -944,15 +889,11 @@ describe("host_bash — proxy delegation", () => {
   });
 
   test("propagates daemon routing env vars to proxy for nested assistant CLI calls", async () => {
-    const envSnapshot = captureEnv([
-      ...ROUTING_ENV_KEYS,
-      "VELLUM_UNTRUSTED_SHELL",
-    ]);
+    const envSnapshot = captureEnv(ROUTING_ENV_KEYS);
     process.env.VELLUM_WORKSPACE_DIR = "/tmp/vellum-instance/.vellum/workspace";
     process.env.VELLUM_DATA_DIR = "/tmp/vellum-instance/.vellum/workspace/data";
     process.env.VELLUM_ENVIRONMENT = "local";
     process.env.INTERNAL_GATEWAY_BASE_URL = "http://127.0.0.1:7830";
-    delete process.env.VELLUM_UNTRUSTED_SHELL;
 
     try {
       const proxyResult: ToolExecutionResult = {
@@ -961,14 +902,9 @@ describe("host_bash — proxy delegation", () => {
       };
       const calls = setupMockProxy(proxyResult);
 
-      const ctx: ToolContext = {
-        ...makeContext(),
-        trustClass: "guardian", // trusted actor — no lockdown
-      };
-
       const result = await hostShellTool.execute(
         { command: "assistant browser status --json" },
-        ctx,
+        makeContext(),
       );
 
       expect(result).toBe(proxyResult);