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

package/src/__tests__/tool-executor-lifecycle-events.test.ts

@@ -3,36 +3,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 import type { ToolExecutionResult } from "../tools/types.js";
 import type { UsageAttributionSnapshot } from "../usage/attribution.js";
 
-const mockConfig = {
-  provider: "anthropic",
-  model: "test",
-  maxTokens: 4096,
-  dataDir: "/tmp",
-  timeouts: {
-    shellDefaultTimeoutSec: 120,
-    shellMaxTimeoutSec: 600,
-    permissionTimeoutSec: 300,
-  },
-  sandbox: {
-    enabled: false,
-    backend: "native" as const,
-    docker: {
-      image: "vellum-sandbox:latest",
-      cpus: 1,
-      memoryMb: 512,
-      pidsLimit: 256,
-      network: "none" as const,
-    },
-  },
-  rateLimit: { maxRequestsPerMinute: 0 },
-  secretDetection: {
-    enabled: false,
-  },
-  permissions: {
-    mode: "workspace" as const,
-  },
-};
-
 let checkerDecision: "allow" | "prompt" | "deny" = "allow";
 let checkerReason = "allowed";
 let checkerRisk = "low";
@@ -108,30 +78,12 @@ mock.module("../telemetry/tool-audit.js", () => ({
   },
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => mockConfig,
-  loadConfig: () => mockConfig,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
-
 // Analytics consent is granted so any consent-gated telemetry path the audit
 // terminals consult sees the opted-in state.
 mock.module("../platform/consent-cache.js", () => ({
   getCachedShareAnalytics: () => true,
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 mock.module("../permissions/checker.js", () => ({
   isDynamicSkillLoadInvocation: () => false,
   classifyRisk: async () => ({ level: checkerRisk }),

package/src/__tests__/tool-executor.test.ts

@@ -9,35 +9,6 @@ import { RiskLevel } from "../permissions/types.js";
 import type { Tool, ToolExecutionResult } from "../tools/types.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 
-const mockConfig = {
-  provider: "anthropic",
-  model: "test",
-  maxTokens: 4096,
-  dataDir: "/tmp",
-  timeouts: {
-    shellDefaultTimeoutSec: 120,
-    shellMaxTimeoutSec: 600,
-    permissionTimeoutSec: 300,
-    questionResponseTimeoutSec: 1800,
-  },
-  sandbox: {
-    enabled: false,
-    backend: "native" as const,
-    docker: {
-      image: "vellum-sandbox:latest",
-      cpus: 1,
-      memoryMb: 512,
-      pidsLimit: 256,
-      network: "none" as const,
-    },
-  },
-  rateLimit: { maxRequestsPerMinute: 0 },
-  secretDetection: {
-    enabled: false,
-  },
-  permissions: {},
-};
-
 let fakeToolResult: ToolExecutionResult = { content: "ok", isError: false };
 
 /** Captured arguments from the last check() call, for assertion in tests. */
@@ -88,24 +59,6 @@ let cachedAssessmentOverride:
     }
   | undefined;
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => mockConfig,
-  loadConfig: () => mockConfig,
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-}));
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 mock.module("../permissions/checker.js", () => ({
   isDynamicSkillLoadInvocation: () => false,
   classifyRisk: async () => ({ level: "low" }),
@@ -178,6 +131,7 @@ mock.module("../tools/shared/filesystem/path-policy.js", () => ({
   hostPolicy: () => ({ ok: false }),
 }));
 
+import { getConfig } from "../config/loader.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import {
   computePerToolTimeoutMs,
@@ -1352,7 +1306,7 @@ describe("computePerToolTimeoutMs ask_question budget", () => {
   // or if the executor budget and the prompter timeout drift onto different
   // config knobs.
   test("execution-timeout budget exceeds the prompt's own questionResponseTimeoutSec", () => {
-    const { questionResponseTimeoutSec } = mockConfig.timeouts;
+    const { questionResponseTimeoutSec } = getConfig().timeouts;
     const askQuestionBudgetMs = computePerToolTimeoutMs("ask_question", {});
 
     expect(askQuestionBudgetMs).toBeGreaterThan(
@@ -1362,7 +1316,7 @@ describe("computePerToolTimeoutMs ask_question budget", () => {
   });
 
   test("the generic budget that would otherwise apply is shorter than the prompt timeout", () => {
-    const { questionResponseTimeoutSec } = mockConfig.timeouts;
+    const { questionResponseTimeoutSec } = getConfig().timeouts;
     const genericBudgetMs = computePerToolTimeoutMs("some_other_tool", {});
 
     // This is the collision the ask_question special case fixes: the generic

package/src/__tests__/tool-grant-request-escalation.test.ts

@@ -12,14 +12,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const testDir = process.env.VELLUM_WORKSPACE_DIR!;
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 // Mock task run rules — no task run rules by default
 mock.module("../tasks/ephemeral-permissions.js", () => ({
   getTaskRunRules: () => [],
@@ -96,17 +88,19 @@ mock.module("../runtime/gateway-client.js", () => ({
   },
 }));
 
-import { applyCanonicalGuardianDecision } from "../approvals/guardian-decision-primitive.js";
+// Grant escalation creates AND decides its guardian request through the
+// gateway client; the sim serves that whole surface.
+import { createGuardianGatewaySim } from "./guardian-gateway-sim.js";
+
+const sim = createGuardianGatewaySim();
+mock.module("../channels/gateway-guardian-requests.js", () => sim.module);
+
+import { applyGuardianDecision } from "../approvals/guardian-decision-primitive.js";
 import type { ActorContext } from "../approvals/guardian-request-resolvers.js";
 import {
   getRegisteredKinds,
   getResolver,
 } from "../approvals/guardian-request-resolvers.js";
-import {
-  createCanonicalGuardianRequest,
-  getCanonicalGuardianRequest,
-  listCanonicalGuardianRequests,
-} from "../contacts/canonical-guardian-store.js";
 import { getDb } from "../persistence/db-connection.js";
 import { getSqlite } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
@@ -125,9 +119,8 @@ await initializeDb();
 function resetTables(): void {
   const db = getDb();
   db.delete(scopedApprovalGrants).run();
-  db.run("DELETE FROM canonical_guardian_deliveries");
-  db.run("DELETE FROM canonical_guardian_requests");
   db.run("DELETE FROM conversations");
+  sim.reset();
   const now = Date.now();
   getSqlite().run(
     "INSERT INTO conversations (id, created_at, updated_at) VALUES (?, ?, ?)",
@@ -135,6 +128,21 @@ function resetTables(): void {
   );
 }
 
+/** Seed a pending tool_grant_request in the gateway sim. */
+function seedGrantRequest(inputDigest: string) {
+  return sim.seedRequest({
+    kind: "tool_grant_request",
+    sourceChannel: "telegram",
+    sourceConversationId: "conv-1",
+    requesterExternalUserId: "requester-1",
+    guardianExternalUserId: "guardian-1",
+    guardianPrincipalId: "test-principal-id",
+    toolName: "bash",
+    inputDigest,
+    expiresAt: Date.now() + 60_000,
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -259,8 +267,8 @@ describe("ToolApprovalHandler / grant-miss escalation", () => {
     // Should get the generic denial message, not escalation
     expect(result.result.content).toContain("verified channel identity");
 
-    // No canonical request should have been created
-    const requests = listCanonicalGuardianRequests({
+    // No guardian request should have been created
+    const requests = await sim.module.listGuardianRequestsOrEmpty({
       kind: "tool_grant_request",
       status: "pending",
     });
@@ -272,27 +280,16 @@ describe("ToolApprovalHandler / grant-miss escalation", () => {
 // 3. Canonical decision and grant minting for tool_grant_request kind
 // ---------------------------------------------------------------------------
 
-describe("applyCanonicalGuardianDecision / tool_grant_request", () => {
+describe("applyGuardianDecision / tool_grant_request", () => {
   beforeEach(() => {
     resetTables();
     deliveredReplies.length = 0;
   });
 
   test("approving tool_grant_request with tool metadata mints a grant", async () => {
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:testdigest",
-      expiresAt: Date.now() + 60_000,
-    });
+    const req = seedGrantRequest("sha256:testdigest");
 
-    const result = await applyCanonicalGuardianDecision({
+    const result = await applyGuardianDecision({
       requestId: req.id,
       action: "approve_once",
       actorContext: guardianActor(),
@@ -304,27 +301,16 @@ describe("applyCanonicalGuardianDecision / tool_grant_request", () => {
     }
     expect(result.grantMinted).toBe(true);
 
-    // Verify canonical request is approved
-    const resolved = getCanonicalGuardianRequest(req.id);
+    // Verify guardian request is approved
+    const resolved = sim.getRequest(req.id);
     expect(resolved!.status).toBe("approved");
     expect(resolved!.decidedByExternalUserId).toBe("guardian-1");
   });
 
   test("rejecting tool_grant_request does NOT mint a grant", async () => {
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:testdigest",
-      expiresAt: Date.now() + 60_000,
-    });
+    const req = seedGrantRequest("sha256:testdigest");
 
-    const result = await applyCanonicalGuardianDecision({
+    const result = await applyGuardianDecision({
       requestId: req.id,
       action: "reject",
       actorContext: guardianActor(),
@@ -336,25 +322,14 @@ describe("applyCanonicalGuardianDecision / tool_grant_request", () => {
     }
     expect(result.grantMinted).toBe(false);
 
-    const resolved = getCanonicalGuardianRequest(req.id);
+    const resolved = sim.getRequest(req.id);
     expect(resolved!.status).toBe("denied");
   });
 
   test("identity mismatch blocks tool_grant_request approval", async () => {
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:testdigest",
-      expiresAt: Date.now() + 60_000,
-    });
+    const req = seedGrantRequest("sha256:testdigest");
 
-    const result = await applyCanonicalGuardianDecision({
+    const result = await applyGuardianDecision({
       requestId: req.id,
       action: "approve_once",
       actorContext: guardianActor({
@@ -368,7 +343,7 @@ describe("applyCanonicalGuardianDecision / tool_grant_request", () => {
     }
     expect(result.reason).toBe("identity_mismatch");
 
-    const unchanged = getCanonicalGuardianRequest(req.id);
+    const unchanged = sim.getRequest(req.id);
     expect(unchanged!.status).toBe("pending");
   });
 });
@@ -385,22 +360,11 @@ describe("end-to-end: tool grant escalation -> approval -> consume", () => {
 
   test("waitForInlineGrant: approve-then-consume round-trip works correctly", async () => {
     // Test the grant lifecycle directly: create request, approve it, consume grant.
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:roundtrip",
-      expiresAt: Date.now() + 60_000,
-    });
+    const req = seedGrantRequest("sha256:roundtrip");
 
     // Schedule guardian approval after 50ms
     setTimeout(async () => {
-      await applyCanonicalGuardianDecision({
+      await applyGuardianDecision({
         requestId: req.id,
         action: "approve_once",
         actorContext: guardianActor(),
@@ -439,23 +403,12 @@ describe("inline wait-and-resume", () => {
   });
 
   test("waitForInlineGrant returns granted when grant appears during wait", async () => {
-    // Create a canonical request manually
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:waitgrant",
-      expiresAt: Date.now() + 60_000,
-    });
+    // Create a guardian request manually
+    const req = seedGrantRequest("sha256:waitgrant");
 
     // Schedule approval after 50ms
     setTimeout(async () => {
-      await applyCanonicalGuardianDecision({
+      await applyGuardianDecision({
         requestId: req.id,
         action: "approve_once",
         actorContext: guardianActor(),
@@ -482,22 +435,11 @@ describe("inline wait-and-resume", () => {
   });
 
   test("waitForInlineGrant returns denied when guardian rejects during wait", async () => {
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:denywait",
-      expiresAt: Date.now() + 60_000,
-    });
+    const req = seedGrantRequest("sha256:denywait");
 
     // Schedule rejection after 50ms
     setTimeout(async () => {
-      await applyCanonicalGuardianDecision({
+      await applyGuardianDecision({
         requestId: req.id,
         action: "reject",
         actorContext: guardianActor(),
@@ -521,18 +463,7 @@ describe("inline wait-and-resume", () => {
   });
 
   test("waitForInlineGrant returns timeout when no decision arrives", async () => {
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:timeoutwait",
-      expiresAt: Date.now() + 60_000,
-    });
+    const req = seedGrantRequest("sha256:timeoutwait");
 
     const start = Date.now();
     const result = await waitForInlineGrant(
@@ -555,18 +486,7 @@ describe("inline wait-and-resume", () => {
   });
 
   test("waitForInlineGrant returns aborted when signal fires during wait", async () => {
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:abortwait",
-      expiresAt: Date.now() + 60_000,
-    });
+    const req = seedGrantRequest("sha256:abortwait");
 
     const controller = new AbortController();
     setTimeout(() => controller.abort(), 50);
@@ -589,23 +509,12 @@ describe("inline wait-and-resume", () => {
 
   test("waitForInlineGrant: guardian rejects -> outcome is denied", async () => {
     // Test rejection via the waitForInlineGrant primitive directly.
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:reject-e2e",
-      expiresAt: Date.now() + 60_000,
-    });
+    const req = seedGrantRequest("sha256:reject-e2e");
 
     // Schedule rejection after 100ms
     const rejectionPromise = (async () => {
       await new Promise((r) => setTimeout(r, 100));
-      await applyCanonicalGuardianDecision({
+      await applyGuardianDecision({
         requestId: req.id,
         action: "reject",
         actorContext: guardianActor(),
@@ -636,18 +545,7 @@ describe("inline wait-and-resume", () => {
 
   test("waitForInlineGrant: abort signal cancels cleanly during wait", async () => {
     // Test abort via the waitForInlineGrant primitive directly.
-    const req = createCanonicalGuardianRequest({
-      kind: "tool_grant_request",
-      sourceType: "channel",
-      sourceChannel: "telegram",
-      conversationId: "conv-1",
-      requesterExternalUserId: "requester-1",
-      guardianExternalUserId: "guardian-1",
-      guardianPrincipalId: "test-principal-id",
-      toolName: "bash",
-      inputDigest: "sha256:abort-e2e",
-      expiresAt: Date.now() + 60_000,
-    });
+    const req = seedGrantRequest("sha256:abort-e2e");
 
     const controller = new AbortController();
     // Abort after 100ms
@@ -701,8 +599,8 @@ describe("inline wait-and-resume", () => {
     // Should be near-instant, no waiting
     expect(elapsed).toBeLessThan(200);
 
-    // No canonical request created
-    const requests = listCanonicalGuardianRequests({
+    // No guardian request created
+    const requests = await sim.module.listGuardianRequestsOrEmpty({
       kind: "tool_grant_request",
       status: "pending",
     });

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -10,35 +10,6 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// ── Mock platform (must precede imports that read it) ─────────────────────────
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    skills: {
-      entries: {},
-      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
-      install: { nodeManager: "npm" },
-      allowBundled: null,
-      remoteProviders: {
-        skillssh: { enabled: true },
-        clawhub: { enabled: true },
-      },
-      remotePolicy: {
-        blockSuspicious: true,
-        blockMalware: true,
-        maxSkillsShRisk: "medium",
-      },
-    },
-  }),
-  loadConfig: () => ({}),
-}));
-
 // ── Mock conversation-crud (used by handleToolResult/handleMessageComplete) ──
 // Reserve returns a role-distinct id so tests can tell the grouped tool-result
 // `user` row apart from the assistant row, and assert it is reserved exactly
@@ -71,6 +42,8 @@ mock.module("../persistence/conversation-crud.js", () => ({
   getConversation: () => null,
   getMessageById: () => null,
   updateMessageContent: updateMessageContentMock,
+  markMessageContentInflight: () => {},
+  finalizeMessageContent: updateMessageContentMock,
   provenanceFromTrustContext: () => ({}),
   reserveMessage: reserveMessageMock,
   recordConversationPersistedSeq: (id: string, seq: number) => {

package/src/__tests__/tool-profiler.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 
 import {
   disposeToolProfiler,
@@ -99,6 +99,55 @@ describe("ToolProfiler", () => {
   });
 });
 
+/**
+ * A `process.memoryUsage` replacement that reproduces the Bun 1.3.11
+ * `SystemError: Failed to get memory usage, errno: 2` syscall failure. Cast to
+ * the real signature because an always-throwing arrow infers a `never` return.
+ */
+const throwingMemoryUsage = (() => {
+  throw new Error("Failed to get memory usage, errno: 2");
+}) as unknown as typeof process.memoryUsage;
+
+describe("ToolProfiler RSS sampling failures", () => {
+  let profiler: ToolProfiler;
+
+  beforeEach(() => {
+    profiler = new ToolProfiler();
+  });
+
+  afterEach(() => {
+    // Restore the real implementation between cases.
+    spyOn(process, "memoryUsage").mockRestore();
+  });
+
+  test("startRequest tolerates a throwing memoryUsage syscall", () => {
+    // Simulate the Bun 1.3.11 `SystemError: Failed to get memory usage` bug.
+    spyOn(process, "memoryUsage").mockImplementation(throwingMemoryUsage);
+
+    expect(() => profiler.startRequest()).not.toThrow();
+  });
+
+  test("recordToolCompletion still records stats when memoryUsage throws", () => {
+    profiler.startRequest();
+    spyOn(process, "memoryUsage").mockImplementation(throwingMemoryUsage);
+
+    // The RSS sample fails, but the tool's timing stats are still recorded and
+    // no exception escapes to the caller (the agent loop).
+    expect(() =>
+      profiler.recordToolCompletion("bash", 123, false),
+    ).not.toThrow();
+
+    const summary = profiler.getSummary();
+    expect(summary.toolCount).toBe(1);
+    expect(summary.tools["bash"]).toEqual({
+      count: 1,
+      totalMs: 123,
+      maxMs: 123,
+      errors: 0,
+    });
+  });
+});
+
 describe("conversation-keyed profiler registry", () => {
   test("recording before a request window is a silent no-op", () => {
     expect(() =>
@@ -125,6 +174,28 @@ describe("conversation-keyed profiler registry", () => {
     ).not.toThrow();
   });
 
+  test("recordToolCompletion swallows profiler failures instead of throwing", () => {
+    startToolProfilingRequest("conv-throwing");
+    const spy = spyOn(process, "memoryUsage").mockImplementation(
+      throwingMemoryUsage,
+    );
+
+    try {
+      // A throwing RSS syscall must never propagate to the executor/agent loop.
+      expect(() =>
+        recordToolCompletion("conv-throwing", "bash", 42, false),
+      ).not.toThrow();
+    } finally {
+      spy.mockRestore();
+    }
+
+    // The turn's timing stats survived even though the RSS sample failed.
+    expect(() =>
+      emitToolProfilingSummary("conv-throwing", "req-throwing"),
+    ).not.toThrow();
+    disposeToolProfiler("conv-throwing");
+  });
+
   test("startToolProfilingRequest resets a conversation's prior window", () => {
     startToolProfilingRequest("conv-reset");
     recordToolCompletion("conv-reset", "bash", 100, false);

package/src/__tests__/tool-result-metadata-plumbing.test.ts

@@ -10,35 +10,6 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// ── Mock platform (must precede imports that read it) ─────────────────────────
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    skills: {
-      entries: {},
-      load: { extraDirs: [], watch: false, watchDebounceMs: 0 },
-      install: { nodeManager: "npm" },
-      allowBundled: null,
-      remoteProviders: {
-        skillssh: { enabled: true },
-        clawhub: { enabled: true },
-      },
-      remotePolicy: {
-        blockSuspicious: true,
-        blockMalware: true,
-        maxSkillsShRisk: "medium",
-      },
-    },
-  }),
-  loadConfig: () => ({}),
-}));
-
 mock.module("../persistence/conversation-crud.js", () => ({
   setConversationProcessingStartedAt: () => {},
   isConversationProcessing: () => false,

package/src/__tests__/tool-side-effects-slack-dm.test.ts

@@ -31,7 +31,6 @@ mock.module("../apps/app-store.js", () => ({
   getApp: mock(() => null),
   getAppDirPath: mock(() => ""),
   getAppsDir: mock(() => ""),
-  isMultifileApp: mock(() => false),
   resolveAppIdFromPath: mock(() => null),
   resolveAppIdByDirName: mock(() => null),
   resolveAppDir: mock(() => ({ dirName: "", dirPath: "" })),