@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/__tests__/slack-inbound-verification.test.ts

@@ -14,13 +14,6 @@ import { 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",
@@ -84,11 +77,11 @@ function seedGatewayGuardian(
   });
 }
 
-import { createCanonicalGuardianRequest } from "../contacts/canonical-guardian-store.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
+import { bridgeState } from "./helpers/gateway-guardian-requests-store-bridge.js";
 import {
   createOutboundSession,
   createOutboundSessionGuarded,
@@ -121,12 +114,11 @@ const TEST_BEARER_TOKEN = "test-token";
 
 function resetState(): void {
   resetVerificationSessionsSim();
+  bridgeState.reset();
   const db = getDb();
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM conversations");
   db.run("DELETE FROM notification_events");
-  db.run("DELETE FROM canonical_guardian_requests");
-  db.run("DELETE FROM canonical_guardian_deliveries");
   db.run("DELETE FROM contact_channels");
   db.run("DELETE FROM contacts");
   gatewayGuardians = [];
@@ -208,14 +200,14 @@ describe("Slack inbound trusted contact verification", () => {
 
   test("a terminally-denied Slack sender gets no challenge and no guardian re-prompt", async () => {
     // Guardian previously denied this sender (terminal). Seed the denied
-    // canonical request under the assistant-scoped conversationId the ingress
+    // guardian request under the assistant-scoped conversationId the ingress
     // path derives for (self, slack, U0123UNKNOWN).
-    createCanonicalGuardianRequest({
+    bridgeState.seedRequest({
       id: `denied-${Date.now()}`,
       kind: "access_request",
       sourceType: "channel",
       sourceChannel: "slack",
-      conversationId: "access-req-self-slack-U0123UNKNOWN",
+      sourceConversationId: "access-req-self-slack-U0123UNKNOWN",
       requesterExternalUserId: "U0123UNKNOWN",
       guardianPrincipalId: "guardian-principal",
       toolName: "ingress_access_request",

package/src/__tests__/{slack-reaction-canonical-approval.test.ts → slack-reaction-guardian-approval.test.ts}

@@ -1,5 +1,5 @@
 /**
- * Tests for guardian approval-by-reaction on the canonical pipeline.
+ * Tests for guardian approval-by-reaction on the guardian decision pipeline.
  *
  * A Slack emoji reaction (✅ / ❌) on a delivered approval card is routed
  * through `routeGuardianReply` exactly like a button press or text reply. The
@@ -11,28 +11,17 @@
 
 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 _conversationMocks = new Map<string, unknown>();
 mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 
-import {
-  createCanonicalGuardianDelivery,
-  createCanonicalGuardianRequest,
-  getCanonicalGuardianRequest,
-  getPendingCanonicalRequestByDestinationMessage,
-  resolveCanonicalGuardianRequest,
-} from "../contacts/canonical-guardian-store.js";
+import { createGuardianGatewaySim } from "./guardian-gateway-sim.js";
+
+const sim = createGuardianGatewaySim();
+mock.module("../channels/gateway-guardian-requests.js", () => sim.module);
+
 import type { Conversation } from "../daemon/conversation.js";
-import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import {
   inferDecisionActionFromFreeText,
@@ -52,16 +41,13 @@ const CHAT_ID = "D_GUARDIAN_DM";
 const TOOL_NAME = "execute_shell";
 
 function resetTables(): void {
-  const db = getDb();
-  db.run("DELETE FROM canonical_guardian_deliveries");
-  db.run("DELETE FROM canonical_guardian_requests");
-  db.run("DELETE FROM scoped_approval_grants");
+  sim.reset();
   pendingInteractions.clear();
   _conversationMocks.clear();
 }
 
 /**
- * Seed a pending tool-approval (canonical request + delivery + pending
+ * Seed a pending tool-approval (gateway request + delivery + pending
  * interaction with a mock conversation) and return the mocked
  * `handleConfirmationResponse` so callers can assert it was driven.
  */
@@ -75,12 +61,11 @@ function seedApproval(opts: {
   const principal = opts.principal ?? PRINCIPAL;
   const conversationId = `conv-${opts.requestId}`;
 
-  createCanonicalGuardianRequest({
+  sim.seedRequest({
     id: opts.requestId,
     kind: "tool_approval",
-    sourceType: "channel",
     sourceChannel: "slack",
-    conversationId,
+    sourceConversationId: conversationId,
     requesterExternalUserId: "requester-1",
     requesterChatId: chatId,
     guardianExternalUserId: GUARDIAN_USER,
@@ -90,7 +75,7 @@ function seedApproval(opts: {
     expiresAt: Date.now() + 300_000,
   });
 
-  createCanonicalGuardianDelivery({
+  sim.seedDelivery({
     requestId: opts.requestId,
     destinationChannel: "slack",
     destinationChatId: chatId,
@@ -142,47 +127,6 @@ function reaction(opts: {
   };
 }
 
-// ---------------------------------------------------------------------------
-// Store lookup
-// ---------------------------------------------------------------------------
-
-describe("getPendingCanonicalRequestByDestinationMessage", () => {
-  beforeEach(resetTables);
-
-  test("resolves the request whose delivery matches channel + chat + message id", () => {
-    seedApproval({ requestId: "req-1", ts: "1700000000.000001" });
-    const found = getPendingCanonicalRequestByDestinationMessage(
-      "slack",
-      CHAT_ID,
-      "1700000000.000001",
-    );
-    expect(found?.id).toBe("req-1");
-  });
-
-  test("returns null when no delivery matches the message id", () => {
-    seedApproval({ requestId: "req-1", ts: "1700000000.000001" });
-    expect(
-      getPendingCanonicalRequestByDestinationMessage(
-        "slack",
-        CHAT_ID,
-        "9999.0",
-      ),
-    ).toBeNull();
-  });
-
-  test("returns null once the matched request is no longer pending", () => {
-    seedApproval({ requestId: "req-1", ts: "1700000000.000001" });
-    resolveCanonicalGuardianRequest("req-1", "pending", { status: "approved" });
-    expect(
-      getPendingCanonicalRequestByDestinationMessage(
-        "slack",
-        CHAT_ID,
-        "1700000000.000001",
-      ),
-    ).toBeNull();
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Reaction routing
 // ---------------------------------------------------------------------------
@@ -200,7 +144,7 @@ describe("routeGuardianReply / reactions", () => {
     expect(result.consumed).toBe(true);
     expect(result.decisionApplied).toBe(true);
     expect(result.type).toBe("canonical_decision_applied");
-    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("approved");
+    expect(sim.getRequest("req-1")?.status).toBe("approved");
     expect(hcr).toHaveBeenCalledTimes(1);
     expect(hcr.mock.calls[0]?.[0]).toBe("req-1");
     expect(hcr.mock.calls[0]?.[1]).toBe("allow");
@@ -214,7 +158,7 @@ describe("routeGuardianReply / reactions", () => {
     );
 
     expect(result.decisionApplied).toBe(true);
-    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("denied");
+    expect(sim.getRequest("req-1")?.status).toBe("denied");
     expect(hcr.mock.calls[0]?.[1]).toBe("deny");
   });
 
@@ -228,8 +172,8 @@ describe("routeGuardianReply / reactions", () => {
     );
 
     expect(result.requestId).toBe("req-B");
-    expect(getCanonicalGuardianRequest("req-B")?.status).toBe("approved");
-    expect(getCanonicalGuardianRequest("req-A")?.status).toBe("pending");
+    expect(sim.getRequest("req-B")?.status).toBe("approved");
+    expect(sim.getRequest("req-A")?.status).toBe("pending");
     expect(hcrB).toHaveBeenCalledTimes(1);
     expect(hcrA).not.toHaveBeenCalled();
   });
@@ -243,7 +187,7 @@ describe("routeGuardianReply / reactions", () => {
 
     expect(result.consumed).toBe(false);
     expect(result.type).toBe("not_consumed");
-    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("pending");
+    expect(sim.getRequest("req-1")?.status).toBe("pending");
   });
 
   test("an unknown emoji is not consumed", async () => {
@@ -254,7 +198,7 @@ describe("routeGuardianReply / reactions", () => {
     );
 
     expect(result.consumed).toBe(false);
-    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("pending");
+    expect(sim.getRequest("req-1")?.status).toBe("pending");
   });
 
   test("a reaction without a reacted message id is not consumed", async () => {
@@ -282,7 +226,7 @@ describe("routeGuardianReply / reactions", () => {
     expect(result.consumed).toBe(true);
     expect(result.decisionApplied).toBe(false);
     expect(result.replyText).toMatch(/permission/i);
-    expect(getCanonicalGuardianRequest("req-1")?.status).toBe("pending");
+    expect(sim.getRequest("req-1")?.status).toBe("pending");
     expect(hcr).not.toHaveBeenCalled();
   });
 });

package/src/__tests__/slack-share-routes.test.ts

@@ -42,7 +42,6 @@ let appStoreResult: unknown = null;
 mock.module("../apps/app-store.js", () => ({
   getApp: (_id: string) => appStoreResult,
   getAppsDir: () => "/tmp/apps",
-  isMultifileApp: () => false,
   listApps: () => [],
 }));
 

package/src/__tests__/slim-skill-category.test.ts

@@ -17,20 +17,6 @@ let mockInstallMeta: SkillInstallMeta | null = null;
 // Module mocks — must be declared before importing the module under test
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({}),
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-}));
-
 mock.module("../config/skills.js", () => ({
   loadSkillCatalog: () => mockSummaries,
 }));

package/src/__tests__/stale-approval-dedup.test.ts

@@ -4,13 +4,6 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 // Mocks — must be declared before importing the module under test
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 const deliveredMessages: Array<{
   url: string;
   body: Record<string, unknown>;

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -2,12 +2,12 @@
  * Regression test for the subagent provider routing fix.
  *
  * Before the fix, `SubagentManager.spawn()` constructed the Conversation with
- * `getProvider(appConfig.llm.default.provider)` directly, which meant per-call
- * `llm.callSites.subagentSpawn.provider` overrides only changed the request
- * *metadata* the downstream client saw — the actual HTTP transport still
- * belonged to `llm.default.provider`. After the fix, the provider is wrapped
- * in `CallSiteRoutingProvider`, which consults the resolver per call and
- * routes to the resolved provider's transport when it differs from the
+ * a `getProvider()` lookup of the default provider directly, which meant
+ * per-call `llm.callSites.subagentSpawn.provider` overrides only changed the
+ * request *metadata* the downstream client saw — the actual HTTP transport
+ * still belonged to the default provider. After the fix, the provider is
+ * wrapped in `CallSiteRoutingProvider`, which consults the resolver per call
+ * and routes to the resolved provider's transport when it differs from the
  * default.
  *
  * This test stubs the `Conversation` constructor and the provider registry
@@ -15,18 +15,11 @@
  * `Conversation`, then verify it's a `CallSiteRoutingProvider` that selects
  * the right transport for the `subagentSpawn` callSite.
  */
-import { beforeAll, describe, expect, mock, test } from "bun:test";
-
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
-
-// Legacy-shaped fixtures (llm.default-centric resolution): pinned to the
-// flag-off cascade. Override-or-default (flag-on) semantics are pinned by
-// llm-resolver-override-or-default.test.ts and its companion suites.
-beforeAll(() => {
-  setOverridesForTesting({ "override-or-default-resolution": false });
-});
+import { afterAll, describe, expect, mock, test } from "bun:test";
 
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import { getProvider as getProviderImport } from "../providers/registry.js";
+import { setConfig } from "./helpers/set-config.js";
 
 // Capture the provider passed to Conversation.
 let capturedProvider: unknown = undefined;
@@ -125,15 +118,27 @@ mock.module("../prompts/system-prompt.js", () => ({
 }));
 
 // Provider registry + connection resolver — routing goes through
-// `provider_connection` exclusively. `getProvider` is kept here purely
-// because the registry module still exports it; the production code under
-// test does not call it.
+// `provider_connection` exclusively. `getProvider` throws while this file's
+// tests run (the production code under test must not call it), and delegates
+// to the real registry afterwards: `mock.module` patches persist for the rest
+// of the `bun test` process, and later test files (e.g. the platform-proxy
+// integration suite) call the real `getProvider`. The real function is
+// snapshotted before `mock.module` rebinds the import.
 const anthropicStub = { name: "anthropic" };
 const openaiStub = { name: "openai" };
 
+const realGetProvider = getProviderImport;
+let legacyGetProviderGuardArmed = true;
+afterAll(() => {
+  legacyGetProviderGuardArmed = false;
+});
+
 mock.module("../providers/registry.js", () => ({
   getProvider: (name: string) => {
-    throw new Error(`legacy getProvider should not be called: ${name}`);
+    if (legacyGetProviderGuardArmed) {
+      throw new Error(`legacy getProvider should not be called: ${name}`);
+    }
+    return realGetProvider(name);
   },
   resolveProviderFromConnection: async (connection: { name: string }) => {
     if (connection.name === "anthropic-conn") {
@@ -173,24 +178,8 @@ mock.module("../persistence/db-connection.js", () => ({
   getDb: () => ({}),
 }));
 
-// Mutable LLM config — tests rewrite this per-case.
-let mockLlmConfig: Record<string, unknown> = {};
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    llm: mockLlmConfig,
-    rateLimit: { maxRequestsPerMinute: 0 },
-  }),
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 // ── Imports (after mocks) ───────────────────────────────────────────────────
 
-import { LLMSchema } from "../config/schemas/llm.js";
 import {
   clearConversations,
   setConversation,
@@ -198,23 +187,42 @@ import {
 import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { SubagentManager } from "../subagent/manager.js";
 
+// Seed the workspace `llm` config per-case. The real loader schema-merges the
+// raw fragment over defaults exactly as the code path reads it.
 function setLlmConfig(raw: unknown): void {
-  mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
+  setConfig("llm", raw);
 }
 
-describe("SubagentManager — provider call-site routing", () => {
-  test("wraps the default provider in CallSiteRoutingProvider", async () => {
-    setLlmConfig({
-      default: {
+/**
+ * Base LLM fixture: the workspace's default identity is a complete
+ * (provider + model) active profile carrying the `provider_connection` —
+ * `activeProfile` wins mainAgent resolution, and connections can only be
+ * declared on profiles (see the note on the second test below).
+ */
+function makeLlmFixture(
+  extras: {
+    profiles?: Record<string, unknown>;
+    callSites?: Record<string, unknown>;
+  } = {},
+): Record<string, unknown> {
+  return {
+    profiles: {
+      primary: {
+        source: "user",
         provider: "anthropic",
         provider_connection: "anthropic-conn",
         model: "claude-opus-4-7",
       },
-      profiles: {
-        // Disable the catalog default so resolution lands on llm.default.
-        balanced: { source: "managed", status: "disabled" },
-      },
-    });
+      ...extras.profiles,
+    },
+    activeProfile: "primary",
+    ...(extras.callSites ? { callSites: extras.callSites } : {}),
+  };
+}
+
+describe("SubagentManager — provider call-site routing", () => {
+  test("wraps the default provider in CallSiteRoutingProvider", async () => {
+    setLlmConfig(makeLlmFixture());
 
     capturedProvider = undefined;
     const manager = new SubagentManager();
@@ -237,25 +245,20 @@ describe("SubagentManager — provider call-site routing", () => {
     // entry would be silently stripped by Zod. The correct shape for an
     // alternate-provider call-site override is a profile reference, defined
     // here as `altOpenai`.
-    setLlmConfig({
-      default: {
-        provider: "anthropic",
-        provider_connection: "anthropic-conn",
-        model: "claude-opus-4-7",
-      },
-      profiles: {
-        // Disable the catalog default so resolution lands on llm.default.
-        balanced: { source: "managed", status: "disabled" },
-        altOpenai: {
-          provider: "openai",
-          provider_connection: "openai-conn",
-          model: "gpt-5.4",
+    setLlmConfig(
+      makeLlmFixture({
+        profiles: {
+          altOpenai: {
+            provider: "openai",
+            provider_connection: "openai-conn",
+            model: "gpt-5.4",
+          },
         },
-      },
-      callSites: {
-        subagentSpawn: { profile: "altOpenai" },
-      },
-    });
+        callSites: {
+          subagentSpawn: { profile: "altOpenai" },
+        },
+      }),
+    );
 
     capturedProvider = undefined;
     const manager = new SubagentManager();
@@ -279,18 +282,8 @@ describe("SubagentManager — provider call-site routing", () => {
   });
 
   test("falls back to default provider when subagentSpawn callSite is absent", async () => {
-    setLlmConfig({
-      default: {
-        provider: "anthropic",
-        provider_connection: "anthropic-conn",
-        model: "claude-opus-4-7",
-      },
-      profiles: {
-        // Disable the catalog default so resolution lands on llm.default.
-        balanced: { source: "managed", status: "disabled" },
-      },
-      // No subagentSpawn override.
-    });
+    // No subagentSpawn override.
+    setLlmConfig(makeLlmFixture());
 
     capturedProvider = undefined;
     const manager = new SubagentManager();
@@ -309,17 +302,7 @@ describe("SubagentManager — provider call-site routing", () => {
   });
 
   test("copies parent guardian and auth context into spawned conversation", async () => {
-    setLlmConfig({
-      default: {
-        provider: "anthropic",
-        provider_connection: "anthropic-conn",
-        model: "claude-opus-4-7",
-      },
-      profiles: {
-        // Disable the catalog default so resolution lands on llm.default.
-        balanced: { source: "managed", status: "disabled" },
-      },
-    });
+    setLlmConfig(makeLlmFixture());
 
     const parentTrustContext = {
       sourceChannel: "vellum",
@@ -364,17 +347,7 @@ describe("SubagentManager — provider call-site routing", () => {
   });
 
   test("copies the parent's plugin scope into the spawned conversation (by value)", async () => {
-    setLlmConfig({
-      default: {
-        provider: "anthropic",
-        provider_connection: "anthropic-conn",
-        model: "claude-opus-4-7",
-      },
-      profiles: {
-        // Disable the catalog default so resolution lands on llm.default.
-        balanced: { source: "managed", status: "disabled" },
-      },
-    });
+    setLlmConfig(makeLlmFixture());
 
     const parentScope = ["caveman", "data"];
 
@@ -405,17 +378,7 @@ describe("SubagentManager — provider call-site routing", () => {
   });
 
   test("propagates a null (unrestricted) parent scope unchanged", async () => {
-    setLlmConfig({
-      default: {
-        provider: "anthropic",
-        provider_connection: "anthropic-conn",
-        model: "claude-opus-4-7",
-      },
-      profiles: {
-        // Disable the catalog default so resolution lands on llm.default.
-        balanced: { source: "managed", status: "disabled" },
-      },
-    });
+    setLlmConfig(makeLlmFixture());
 
     capturedConversations.length = 0;
     clearConversations();
@@ -444,7 +407,6 @@ describe("SubagentManager — provider call-site routing", () => {
 describe("CallSiteRoutingProvider — selectProvider behavior", () => {
   test("routes to the resolved provider when callSite resolves to a profile with provider_connection", async () => {
     setLlmConfig({
-      default: { provider: "anthropic", model: "claude-opus-4-7" },
       profiles: {
         altOpenai: {
           provider: "openai",
@@ -505,7 +467,6 @@ describe("CallSiteRoutingProvider — selectProvider behavior", () => {
 
   test("routes to default when no callSite provided", async () => {
     setLlmConfig({
-      default: { provider: "anthropic", model: "claude-opus-4-7" },
       callSites: {
         subagentSpawn: { provider: "openai", model: "gpt-5.4" },
       },

package/src/__tests__/subagent-detail.test.ts

@@ -15,7 +15,7 @@ function msg(role: string, content: unknown[]): MessageRow {
     id: `msg-${msgCounter}`,
     conversationId: "conv-1",
     role,
-    content: JSON.stringify(content),
+    content: content as MessageRow["content"],
     createdAt: Date.now(),
     metadata: null,
     clientMessageId: null,

package/src/__tests__/subagent-fork-prompt-role.test.ts

@@ -102,22 +102,10 @@ mock.module("../providers/call-site-routing.js", () => ({
   wrapWithCallSiteRouting: (p: unknown) => p,
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    llm: { default: { provider: "anthropic", model: "claude-opus-4-7" } },
-    rateLimit: { maxRequestsPerMinute: 0 },
-  }),
-}));
-
 mock.module("../config/llm-resolver.js", () => ({
   resolveCallSiteConfig: () => ({ provider: "anthropic", maxTokens: 8192 }),
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 // ── Imports (after mocks) ───────────────────────────────────────────────────
 
 import { clearConversations } from "../daemon/conversation-registry.js";

package/src/__tests__/subagent-notify-parent.test.ts

@@ -79,6 +79,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: () => {},
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
 import { isToolActiveForContext } from "../daemon/conversation-tool-setup.js";
 import type { SubagentRecord } from "../persistence/subagent-store.js";
 import { notifyParentFromChild } from "../subagent/notify.js";
@@ -170,9 +171,8 @@ describe("notify_parent tool definition", () => {
       preactivatedSkillIds: [],
       skillProjectionState: new Map(),
       skillProjectionCache: new Map(),
-      coreToolNames: new Set<string>(),
       toolsDisabledDepth: 0,
-    } as unknown as import("../daemon/conversation-tool-setup.js").SkillProjectionContext;
+    } as unknown as Conversation;
     expect(isToolActiveForContext("notify_parent", ctx)).toBe(false);
   });
 
@@ -181,9 +181,8 @@ describe("notify_parent tool definition", () => {
       preactivatedSkillIds: [],
       skillProjectionState: new Map(),
       skillProjectionCache: new Map(),
-      coreToolNames: new Set<string>(),
       toolsDisabledDepth: 0,
-    } as unknown as import("../daemon/conversation-tool-setup.js").SkillProjectionContext;
+    } as unknown as Conversation;
     expect(isToolActiveForContext("notify_parent", ctx)).toBe(false);
   });
 
@@ -193,9 +192,8 @@ describe("notify_parent tool definition", () => {
       preactivatedSkillIds: [],
       skillProjectionState: new Map(),
       skillProjectionCache: new Map(),
-      coreToolNames: new Set<string>(),
       toolsDisabledDepth: 0,
-    } as unknown as import("../daemon/conversation-tool-setup.js").SkillProjectionContext;
+    } as unknown as Conversation;
     expect(isToolActiveForContext("notify_parent", ctx)).toBe(true);
   });
 });

package/src/__tests__/subagent-spawn-and-await.test.ts

@@ -162,19 +162,6 @@ mock.module("../providers/call-site-routing.js", () => ({
   wrapWithCallSiteRouting: (provider: unknown) => provider,
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    llm: {
-      default: {
-        provider: "anthropic",
-        provider_connection: "anthropic-conn",
-        model: "claude-opus-4-7",
-      },
-    },
-    rateLimit: { maxRequestsPerMinute: 0 },
-  }),
-}));
-
 mock.module("../config/llm-resolver.js", () => ({
   resolveCallSiteConfig: () => ({
     provider: "anthropic",
@@ -183,11 +170,6 @@ mock.module("../config/llm-resolver.js", () => ({
   }),
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 // ── Imports (after mocks) ───────────────────────────────────────────────────
 
 import {