@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -63,14 +63,6 @@ import {
   GUARDIAN_VERIFY_TEMPLATE_KEYS,
 } from "../runtime/verification-templates.js";
 
-// ---------------------------------------------------------------------------
-// DB initialization
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  initializeDb();
-});
-
 // ---------------------------------------------------------------------------
 // Template tests: channel verification reply templates are deterministic
 // ---------------------------------------------------------------------------
@@ -181,6 +173,10 @@ describe("TwiML parameter propagation", () => {
 // ---------------------------------------------------------------------------
 
 describe("Call session mode metadata", () => {
+  beforeEach(async () => {
+    await initializeDb();
+  });
+
   test("createCallSession persists callMode and verificationSessionId", async () => {
     // Dynamic import to avoid circular dependency issues
     const { createCallSession, getCallSession } =
@@ -239,6 +235,10 @@ describe("Call session mode metadata", () => {
 // ---------------------------------------------------------------------------
 
 describe("Verification control messages are deterministic (guard)", () => {
+  beforeEach(async () => {
+    await initializeDb();
+  });
+
   test("handleChannelInbound does not call processMessage for /start gv_<token> bootstrap commands", async () => {
     const { createHash, randomBytes } = await import("node:crypto");
 
@@ -302,6 +302,12 @@ describe("Verification control messages are deterministic (guard)", () => {
           replyCallbackUrl: "http://localhost/callback",
           sourceMetadata: {
             commandIntent: { type: "start", payload: `gv_${bootstrapToken}` },
+            // Gateway stamps a stranger verdict for this not-yet-bound user;
+            // the bootstrap intercept still fires for a present stranger.
+            trustVerdict: {
+              trustClass: "unknown",
+              canonicalSenderId: "user-bootstrap-123",
+            },
           },
         }),
       });
@@ -367,6 +373,18 @@ describe("Verification control messages are deterministic (guard)", () => {
         actorDisplayName: blockedIdentity.displayName,
         sourceMetadata: {
           commandIntent: { type: "start", payload: `gv_${bootstrapToken}` },
+          // Gateway stamps the member verdict surfacing the blocked status; the
+          // ACL hard-deny fires before the bootstrap intercept.
+          trustVerdict: {
+            trustClass: "unknown",
+            canonicalSenderId: blockedIdentity.externalUserId,
+            contactId: "contact-blocked-bootstrap",
+            channelId: "channel-blocked-bootstrap",
+            type: blockedIdentity.sourceChannel,
+            address: blockedIdentity.externalUserId,
+            status: blockedIdentity.status,
+            policy: blockedIdentity.policy,
+          },
         },
       }),
     });

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

@@ -96,6 +96,9 @@ const {
 } = await import("../tools/background-tool-registry.js");
 const { shellTool } = await import("../tools/terminal/shell.js");
 const { hostShellTool } = await import("../tools/host-terminal/host-shell.js");
+const { __clearRegistryForTesting: clearToolRegistryForTesting, registerTool } =
+  await import("../tools/registry.js");
+const { skillLoadTool } = await import("../tools/skills/load.js");
 
 function makeToolDef(name: string): ToolDefinition {
   return { name, description: `${name} tool`, input_schema: {} };
@@ -124,12 +127,15 @@ function setDiskUsage(usedMb: number, totalMb = 100): void {
 
 beforeEach(() => {
   _clearRegistryForTesting();
+  clearToolRegistryForTesting();
+  registerTool(skillLoadTool);
   __resetDiskPressureGuardForTests();
   setDiskUsage(10);
 });
 
 afterEach(() => {
   _clearRegistryForTesting();
+  clearToolRegistryForTesting();
   __resetDiskPressureGuardForTests();
   diskSample = null;
 });
@@ -140,6 +146,7 @@ describe("disk pressure cleanup tool restrictions", () => {
       makeToolDef("bash"),
       makeToolDef("host_bash"),
       makeToolDef("file_read"),
+      makeToolDef("skill_load"),
       makeToolDef("file_write"),
       makeToolDef("skill_execute"),
       makeToolDef("web_fetch"),
@@ -150,8 +157,14 @@ describe("disk pressure cleanup tool restrictions", () => {
     const cleanupTools = resolve([]);
     const cleanupNames = cleanupTools.map((tool) => tool.name).sort();
 
-    expect(cleanupNames).toEqual(["bash", "file_read", "host_bash"]);
+    expect(cleanupNames).toEqual([
+      "bash",
+      "file_read",
+      "host_bash",
+      "skill_load",
+    ]);
     expect(ctx.allowedToolNames?.has("bash")).toBe(true);
+    expect(ctx.allowedToolNames?.has("skill_load")).toBe(true);
     expect(ctx.allowedToolNames?.has("file_write")).toBe(false);
     expect(ctx.allowedToolNames?.has("skill_execute")).toBe(false);
 
@@ -192,6 +205,33 @@ describe("disk pressure cleanup tool restrictions", () => {
     );
   });
 
+  test("executor fallback allows normal skill_load during cleanup mode", async () => {
+    const handler = new ToolApprovalHandler();
+    const result = await handler.checkPreExecutionGates(
+      "skill_load",
+      { skill: "system-storage-cleanup" },
+      {
+        workingDir: "/workspace",
+        conversationId: "conv-cleanup",
+        trustClass: "guardian",
+        allowedToolNames: new Set(["skill_load"]),
+        diskPressureCleanupModeActive: true,
+      },
+      "sandbox",
+      "low",
+      Date.now(),
+      () => undefined,
+    );
+
+    expect(result.allowed).toBe(true);
+    if (!result.allowed) {
+      throw new Error(
+        "Expected disk pressure cleanup mode to allow skill_load",
+      );
+    }
+    expect(result.tool.name).toBe("skill_load");
+  });
+
   test("locking cancels registered terminal background tools with disk pressure reason", () => {
     const bashCancel = mock((_reason?: string) => undefined);
     const hostCancel = mock((_reason?: string) => undefined);

package/src/__tests__/dm-backfill.test.ts

@@ -88,7 +88,7 @@ import {
 } from "../messaging/providers/slack/message-metadata.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/__tests__/drop-capability-card-state-migration.test.ts

@@ -117,17 +117,9 @@ describe("migrateDropCapabilityCardState", () => {
       .query(`SELECT key FROM memory_checkpoints ORDER BY key`)
       .all() as Array<{ key: string }>;
     expect(checkpointKeys.map((row) => row.key)).toEqual([
-      "migration_drop_capability_card_state_v1",
       "other_checkpoint",
     ]);
 
-    const migrationCheckpoint = raw
-      .query(
-        `SELECT value FROM memory_checkpoints WHERE key = 'migration_drop_capability_card_state_v1'`,
-      )
-      .get() as { value: string } | null;
-    expect(migrationCheckpoint?.value).toBe("1");
-
     const legacyTable = raw
       .query(
         `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'capability_card_categories'`,

package/src/__tests__/edit-propagation.test.ts

@@ -27,7 +27,7 @@ import { messages } from "../memory/schema.js";
 import { readSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 import { handleEditIntercept } from "../runtime/routes/inbound-stages/edit-intercept.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -57,6 +57,21 @@ mock.module("../notifications/decisions-store.js", () => ({
 mock.module("../notifications/deterministic-checks.js", () => ({
   runDeterministicChecks: (...args: unknown[]) =>
     runDeterministicChecksMock(...args),
+  // emit-signal also imports checkSourceActiveSuppression for the pre-decision
+  // gate. Mirror its real signal-only contract here so the gate behaves under
+  // the mock without depending on bun's export-merge semantics. The real
+  // implementation is unit-tested in
+  // notifications/__tests__/deterministic-checks.test.ts.
+  checkSourceActiveSuppression: (signal: {
+    attentionHints: { visibleInSourceNow?: boolean };
+  }) =>
+    signal.attentionHints.visibleInSourceNow
+      ? {
+          passed: false,
+          reason:
+            "Source-active suppression: user is already viewing the source context",
+        }
+      : { passed: true },
 }));
 
 mock.module("../notifications/events-store.js", () => ({
@@ -215,3 +230,71 @@ describe("emitNotificationSignal routing intent re-persistence", () => {
     expect(callArgs?.[1]).toEqual(["vellum"]);
   });
 });
+
+describe("emitNotificationSignal source-active pre-gate", () => {
+  beforeEach(() => {
+    evaluateSignalMock.mockReset();
+    runDeterministicChecksMock.mockReset();
+    createEventMock.mockReset();
+    dispatchDecisionMock.mockReset();
+
+    createEventMock.mockReturnValue({ id: "evt-src-active" });
+    runDeterministicChecksMock.mockResolvedValue({ passed: true });
+    dispatchDecisionMock.mockResolvedValue({
+      dispatched: true,
+      reason: "ok",
+      deliveryResults: [],
+    });
+  });
+
+  test("suppresses visibleInSourceNow signals before the decision engine runs", async () => {
+    const result = await emitNotificationSignal({
+      sourceEventName: "ingress.trusted_contact.verification_sent",
+      sourceChannel: "slack",
+      sourceContextId: "conv-1",
+      attentionHints: {
+        requiresAction: false,
+        urgency: "low",
+        isAsyncBackground: true,
+        visibleInSourceNow: true,
+      },
+      contextPayload: { verificationSessionId: "vs-1" },
+    });
+
+    // The event row is still persisted (audit trail), but the signal
+    // short-circuits before the LLM-backed decision stage and never dispatches.
+    expect(createEventMock).toHaveBeenCalledTimes(1);
+    expect(evaluateSignalMock).not.toHaveBeenCalled();
+    expect(runDeterministicChecksMock).not.toHaveBeenCalled();
+    expect(dispatchDecisionMock).not.toHaveBeenCalled();
+    expect(result.dispatched).toBe(false);
+    expect(result.reason).toContain("Source-active suppression");
+  });
+
+  test("does not short-circuit when visibleInSourceNow is false", async () => {
+    evaluateSignalMock.mockResolvedValue({
+      shouldNotify: false,
+      selectedChannels: [],
+      reasoningSummary: "no notify",
+      renderedCopy: {},
+      dedupeKey: "dk-not-source-active",
+      confidence: 0.5,
+      fallbackUsed: false,
+    });
+
+    await emitNotificationSignal({
+      sourceEventName: "schedule.notify",
+      sourceChannel: "scheduler",
+      sourceContextId: "conv-2",
+      attentionHints: {
+        requiresAction: false,
+        urgency: "low",
+        isAsyncBackground: true,
+        visibleInSourceNow: false,
+      },
+      contextPayload: {},
+    });
+
+    expect(evaluateSignalMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/empty-response-hook.test.ts

@@ -326,6 +326,48 @@ describe("empty-response post-model-call hook — default decisions", () => {
     expect(ctx.decision).toBe("stop");
     expect(ctx.messages).toEqual([priorToolUseTurn]);
   });
+
+  // ─── Call-site gating ──────────────────────────────────────────────────────
+
+  test("empty turn after tools on a non-mainAgent call site → stop, no nudge", async () => {
+    // GIVEN an empty-after-tools turn that would nudge on the user-facing reply,
+    // but the call site is a background one (a memory retrospective). There is
+    // no user awaiting a summary, so the re-query nudge must not fire.
+    const ctx = makeCtx({
+      callSite: "memoryRetrospective",
+      messages: [priorToolUseTurn],
+      content: [],
+    });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the turn ends silently — no nudge appended, no re-query.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toEqual([priorToolUseTurn]);
+  });
+
+  test("refusal on a non-mainAgent call site is still rewritten to the fallback", async () => {
+    // GIVEN a refusal with no visible text on a background call site. The
+    // call-site gate scopes only the re-query nudge; the refusal-rewrite is a
+    // user-facing terminal fallback for any consumer that reads the final text,
+    // so it stays ungated.
+    const ctx = makeCtx({
+      callSite: "memoryRetrospective",
+      messages: [],
+      content: [],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the empty refusal is still rewritten to the user-facing fallback.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.content).toEqual([
+      { type: "text", text: REFUSAL_FALLBACK_TEXT },
+    ]);
+  });
 });
 
 // ─── One-shot retry bound ────────────────────────────────────────────────────

package/src/__tests__/events-client-registration.test.ts

@@ -40,7 +40,7 @@ import {
 } from "../runtime/routes/errors.js";
 import { handleSubscribeAssistantEvents } from "../runtime/routes/events-routes.js";
 
-initializeDb();
+await initializeDb();
 
 describe("events client registration", () => {
   // ── Registration on connect ───────────────────────────────────────────────

package/src/__tests__/followup-tools.test.ts

@@ -23,7 +23,7 @@ import { executeFollowupList } from "../tools/followups/followup_list.js";
 import { executeFollowupResolve } from "../tools/followups/followup_resolve.js";
 import type { ToolContext } from "../tools/types.js";
 
-initializeDb();
+await initializeDb();
 
 function getRawDb(): Database {
   return (getDb() as unknown as { $client: Database }).$client;

package/src/__tests__/gemini-count-tokens.test.ts

@@ -0,0 +1,70 @@
+/**
+ * Coverage for GeminiProvider.countInputTokens — the real Gemini tokenizer via
+ * `models.countTokens`. Mirrors generateContent's composition (contents +
+ * systemInstruction + tool function declarations); throws when the endpoint
+ * returns no `totalTokens` so the daemon falls back to the local estimate.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+let lastCountParams: Record<string, unknown> | undefined;
+let countResult: { totalTokens?: number } = { totalTokens: 1234 };
+
+mock.module("@google/genai", () => ({
+  GoogleGenAI: class {
+    constructor() {}
+    models = {
+      countTokens: async (params: Record<string, unknown>) => {
+        lastCountParams = params;
+        return countResult;
+      },
+    };
+  },
+  ApiError: class extends Error {},
+  ThinkingLevel: {
+    MINIMAL: "MINIMAL",
+    LOW: "LOW",
+    MEDIUM: "MEDIUM",
+    HIGH: "HIGH",
+  },
+}));
+
+import { GeminiProvider } from "../providers/gemini/client.js";
+import type { Message, ToolDefinition } from "../providers/types.js";
+
+const messages: Message[] = [
+  { role: "user", content: [{ type: "text", text: "hello" }] },
+];
+const tools: ToolDefinition[] = [
+  { name: "lookup", description: "d", input_schema: { type: "object" } },
+];
+
+describe("GeminiProvider.countInputTokens", () => {
+  test("returns totalTokens and forwards model + system + tools", async () => {
+    countResult = { totalTokens: 1234 };
+    const provider = new GeminiProvider("key", "gemini-3-flash-preview");
+
+    const count = await provider.countInputTokens(
+      messages,
+      "sys prompt",
+      tools,
+    );
+
+    expect(count).toBe(1234);
+    expect(lastCountParams?.model).toBe("gemini-3-flash-preview");
+    const config = lastCountParams?.config as Record<string, unknown>;
+    expect(config.systemInstruction).toBe("sys prompt");
+    const cfgTools = config.tools as Array<{
+      functionDeclarations: Array<{ name: string }>;
+    }>;
+    expect(cfgTools[0].functionDeclarations[0].name).toBe("lookup");
+    expect(Array.isArray(lastCountParams?.contents)).toBe(true);
+  });
+
+  test("throws when the endpoint returns no totalTokens (caller falls back)", async () => {
+    countResult = {};
+    const provider = new GeminiProvider("key", "gemini-3-flash-preview");
+    await expect(
+      provider.countInputTokens(messages, "sys", undefined),
+    ).rejects.toThrow();
+  });
+});

package/src/__tests__/guardian-action-sweep.test.ts

@@ -24,7 +24,7 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { conversations, messages } from "../memory/schema.js";
 
-initializeDb();
+await initializeDb();
 
 function ensureConversation(id: string): void {
   const db = getDb();
@@ -62,7 +62,14 @@ describe("sendGuardianExpiryNotices", () => {
 
   test("sends external channel expiry notices for sent deliveries", async () => {
     await sendGuardianExpiryNotices(
-      [makeDelivery({ status: "sent" }), makeDelivery({ id: "d2", status: "pending", destinationChatId: "chat-456" })],
+      [
+        makeDelivery({ status: "sent" }),
+        makeDelivery({
+          id: "d2",
+          status: "pending",
+          destinationChatId: "chat-456",
+        }),
+      ],
       "assistant-1",
     );
 

package/src/__tests__/guardian-binding-drift-heal.test.ts

@@ -13,7 +13,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { healGuardianBindingDrift } from "../runtime/guardian-vellum-migration.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

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

@@ -35,7 +35,7 @@ import {
   recordGuardianRequestDeliveries,
 } from "../notifications/canonical-delivery-recorder.js";
 
-initializeDb();
+await initializeDb();
 
 const PRINCIPAL_ID = "withdrawal-test-principal";
 

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

@@ -26,7 +26,7 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { scopedApprovalGrants } from "../memory/schema.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

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

@@ -68,7 +68,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { conversations } from "../memory/schema.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 function ensureConversation(id: string): void {
   const db = getDb();

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

@@ -105,7 +105,7 @@ import {
 import { resetDbForTesting } from "./db-test-helpers.js";
 
 // Initialize the database (creates all tables)
-initializeDb();
+await initializeDb();
 
 afterAll(() => {
   globalThis.fetch = originalFetch;
@@ -115,11 +115,6 @@ afterAll(() => {
 function resetTables(): void {
   const db = getDb();
   db.run("DELETE FROM channel_verification_sessions");
-  try {
-    db.run("DELETE FROM channel_guardian_approval_requests");
-  } catch {
-    /* table may not exist */
-  }
   try {
     db.run("DELETE FROM channel_guardian_rate_limits");
   } catch {
@@ -442,9 +437,9 @@ describe("HTTP route: handleCreateVerificationSession (guardian path)", () => {
 
 describe("HTTP route: handleResendVerificationSession (guardian path)", () => {
   test("throws BadRequestError when channel is missing", async () => {
-    await expect(
-      handleResendVerificationSession({ body: {} }),
-    ).rejects.toThrow(BadRequestError);
+    await expect(handleResendVerificationSession({ body: {} })).rejects.toThrow(
+      BadRequestError,
+    );
   });
 
   test("throws BadRequestError for no_active_session", async () => {
@@ -483,9 +478,9 @@ describe("HTTP route: handleResendVerificationSession (guardian path)", () => {
 
 describe("HTTP route: handleCancelVerificationSession (guardian path)", () => {
   test("throws BadRequestError when channel is missing", async () => {
-    await expect(
-      handleCancelVerificationSession({ body: {} }),
-    ).rejects.toThrow(BadRequestError);
+    await expect(handleCancelVerificationSession({ body: {} })).rejects.toThrow(
+      BadRequestError,
+    );
   });
 
   test("returns success even when no active session exists", async () => {

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

@@ -15,7 +15,7 @@ import {
 } from "../memory/canonical-guardian-store.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

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

@@ -55,7 +55,7 @@ import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { parseCallbackData } from "../runtime/routes/channel-route-shared.js";
 import { listGuardianDecisionPrompts } from "../runtime/routes/guardian-action-routes.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();
@@ -226,10 +226,8 @@ describe("routing invariant: all decision paths reference applyCanonicalGuardian
   test("guardian-reply-router routes all decisions through applyCanonicalGuardianDecision", () => {
     const fullPath = join(srcRoot, "runtime/guardian-reply-router.ts");
     const source = readFileSync(fullPath, "utf-8");
-    // The router must import and call the canonical primitive, not applyGuardianDecision
+    // The router must import and call the canonical decision primitive.
     expect(source).toContain("applyCanonicalGuardianDecision");
-    // The router must NOT directly call the legacy applyGuardianDecision
-    expect(source).not.toContain("applyGuardianDecision(");
   });
 });
 

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

@@ -31,12 +31,11 @@ import {
 } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();
   db.run("DELETE FROM channel_inbound_events");
-  db.run("DELETE FROM channel_guardian_approval_requests");
   db.run("DELETE FROM canonical_guardian_requests");
   db.run("DELETE FROM conversation_keys");
   db.run("DELETE FROM messages");

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

@@ -90,7 +90,7 @@ import { getOrCreateConversation } from "../memory/conversation-key-store.js";
 import { initializeDb } from "../memory/db-init.js";
 import { getBindingByConversation } from "../memory/external-conversation-store.js";
 
-initializeDb();
+await initializeDb();
 
 describe("startVerificationCall — voice binding", () => {
   beforeEach(() => {

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

@@ -482,9 +482,9 @@ describe("browser_mode wiring through tool execution", () => {
     expect(result.isError).toBe(false);
   });
 
-  // ── Auto mode still works without browser_mode ────────────────
+  // ── Default browser selection works without browser_mode ──────
 
-  test("auto mode works when browser_mode is not specified", async () => {
+  test("default browser selection works when browser_mode is not specified", async () => {
     const result = await executeBrowserSnapshot({}, ctx);
     expect(result.isError).toBe(false);
   });

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

@@ -26,6 +26,10 @@ mock.module("../config/loader.js", () => ({
       activeHoursStart: undefined,
       activeHoursEnd: undefined,
     },
+    timeouts: {
+      backgroundTurnTimeoutSec: 1800,
+      scheduleTurnTimeoutSec: 1800,
+    },
   }),
   loadConfig: () => ({}),
   loadRawConfig: () => ({}),

package/src/__tests__/heartbeat-service.test.ts

@@ -47,6 +47,9 @@ let mockConfig = {
     activeHoursEnd: undefined as number | undefined,
     disposition: "Default disposition text mentioning notifications skill.",
   },
+  timeouts: {
+    backgroundTurnTimeoutSec: 1800,
+  },
 };
 
 mock.module("../config/loader.js", () => ({
@@ -399,6 +402,9 @@ describe("HeartbeatService", () => {
         activeHoursEnd: undefined,
         disposition: "Default disposition text mentioning notifications skill.",
       },
+      timeouts: {
+        backgroundTurnTimeoutSec: 1800,
+      },
     };
   });