@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/__tests__/compaction-ledger-store.test.ts

@@ -0,0 +1,128 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+import {
+  appendCompactionEvent,
+  forkCompactionLedger,
+  getLatestCompactionEventAtOrBefore,
+} from "../memory/compaction-ledger-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import {
+  conversationCompactionEvents,
+  conversations,
+} from "../memory/schema.js";
+
+await initializeDb();
+
+function reset(): void {
+  const db = getDb();
+  db.delete(conversationCompactionEvents).run();
+  db.delete(conversations).run();
+}
+
+function makeConversation(id: string): void {
+  const now = Date.now();
+  getDb()
+    .insert(conversations)
+    .values({ id, title: id, createdAt: now, updatedAt: now })
+    .run();
+}
+
+function forkEventsFor(conversationId: string) {
+  return getDb()
+    .select()
+    .from(conversationCompactionEvents)
+    .where(eq(conversationCompactionEvents.conversationId, conversationId))
+    .all();
+}
+
+describe("compaction-ledger-store", () => {
+  beforeEach(reset);
+
+  test("getLatestCompactionEventAtOrBefore returns the newest event at-or-before the cutoff", () => {
+    makeConversation("conv");
+    appendCompactionEvent("conv", {
+      compactedAt: 100,
+      summary: "s100",
+      compactedMessageCount: 1,
+    });
+    appendCompactionEvent("conv", {
+      compactedAt: 200,
+      summary: "s200",
+      compactedMessageCount: 3,
+    });
+    appendCompactionEvent("conv", {
+      compactedAt: 300,
+      summary: "s300",
+      compactedMessageCount: 5,
+    });
+
+    expect(getLatestCompactionEventAtOrBefore("conv", 50)).toBeNull();
+    expect(
+      getLatestCompactionEventAtOrBefore("conv", 100)?.compactedMessageCount,
+    ).toBe(1);
+    expect(
+      getLatestCompactionEventAtOrBefore("conv", 250)?.compactedMessageCount,
+    ).toBe(3);
+    expect(
+      getLatestCompactionEventAtOrBefore("conv", 999)?.compactedMessageCount,
+    ).toBe(5);
+    expect(getLatestCompactionEventAtOrBefore("conv", null)).toBeNull();
+  });
+
+  test("getLatestCompactionEventAtOrBefore is scoped per conversation", () => {
+    makeConversation("a");
+    makeConversation("b");
+    appendCompactionEvent("a", {
+      compactedAt: 100,
+      summary: "a",
+      compactedMessageCount: 1,
+    });
+
+    expect(getLatestCompactionEventAtOrBefore("b", 999)).toBeNull();
+  });
+
+  test("forkCompactionLedger copies only events at-or-before the boundary", () => {
+    makeConversation("src");
+    makeConversation("fork");
+    appendCompactionEvent("src", {
+      compactedAt: 100,
+      summary: "s100",
+      compactedMessageCount: 1,
+    });
+    appendCompactionEvent("src", {
+      compactedAt: 300,
+      summary: "s300",
+      compactedMessageCount: 5,
+    });
+
+    forkCompactionLedger(getDb(), "src", "fork", 200);
+
+    const copied = forkEventsFor("fork");
+    expect(copied).toHaveLength(1);
+    expect(copied[0]?.compactedAt).toBe(100);
+    expect(copied[0]?.summary).toBe("s100");
+  });
+
+  test("forkCompactionLedger with a null boundary copies nothing", () => {
+    makeConversation("src");
+    makeConversation("fork");
+    appendCompactionEvent("src", {
+      compactedAt: 100,
+      summary: "s100",
+      compactedMessageCount: 1,
+    });
+
+    forkCompactionLedger(getDb(), "src", "fork", null);
+
+    expect(forkEventsFor("fork")).toHaveLength(0);
+  });
+});

package/src/__tests__/compaction.benchmark.test.ts

@@ -17,6 +17,8 @@ mock.module("../util/logger.js", () => ({
 // The compactor reads the conversation's image attachments from the DB to
 // build its manifest; with no images these return empty.
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getMessages: () => [],
 }));
 mock.module("../memory/attachments-store.js", () => ({

package/src/__tests__/compactor-call-site-logging.test.ts

@@ -30,6 +30,8 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getMessages: () => [],
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));

package/src/__tests__/compactor-low-watermark-cut.test.ts

@@ -32,6 +32,8 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getMessages: () => [],
 }));
 

package/src/__tests__/compactor-preserved-tail-count.test.ts

@@ -22,6 +22,8 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getMessages: () => [],
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));

package/src/__tests__/compactor-summary-call-truncation.test.ts

@@ -32,6 +32,8 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getMessages: () => [],
 }));
 

package/src/__tests__/compactor-web-search-strip.test.ts

@@ -22,6 +22,8 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getMessages: () => [],
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));

package/src/__tests__/config-loader-backfill.test.ts

@@ -98,6 +98,64 @@ function writeConfig(obj: unknown): void {
   writeFileSync(CONFIG_PATH, JSON.stringify(obj, null, 2) + "\n");
 }
 
+function latencySeed(): Record<string, unknown> {
+  return {
+    model: "claude-haiku-4-5-20251001",
+    effort: "low",
+    thinking: { enabled: false },
+  };
+}
+
+function fullSeededCallSites(): Record<string, Record<string, unknown>> {
+  return {
+    guardianQuestionCopy: latencySeed(),
+    interactionClassifier: latencySeed(),
+    skillCategoryInference: latencySeed(),
+    inviteInstructionGenerator: latencySeed(),
+    notificationDecision: latencySeed(),
+    preferenceExtraction: latencySeed(),
+    commitMessage: {
+      model: "claude-haiku-4-5-20251001",
+      maxTokens: 120,
+      temperature: 0.2,
+      effort: "low",
+      thinking: { enabled: false },
+    },
+    conversationStarters: latencySeed(),
+    conversationSummarization: {
+      model: "claude-opus-4-7",
+      effort: "low",
+      thinking: { enabled: false },
+    },
+    recall: {
+      profile: "cost-optimized",
+      maxTokens: 4096,
+      effort: "low",
+      thinking: { enabled: false, streamThinking: false },
+      temperature: 0,
+      disableCache: true,
+    },
+    heartbeatAgent: {
+      profile: "cost-optimized",
+      maxTokens: 2048,
+      effort: "low",
+      temperature: 0,
+      thinking: { enabled: false, streamThinking: false },
+      contextWindow: { maxInputTokens: 16000 },
+    },
+    replySuggestion: {
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+      thinking: { enabled: false },
+      disableCache: true,
+    },
+    memoryRouter: {
+      profile: "cost-optimized",
+      contextWindow: { maxInputTokens: 1_000_000 },
+    },
+  };
+}
+
 function mergeDefaultConfigAndSeedInferenceProfiles(db?: DrizzleDb): void {
   const defaultConfigMerge = mergeDefaultWorkspaceConfig();
   seedInferenceProfiles({
@@ -372,6 +430,56 @@ describe("loadConfig startup behavior", () => {
     expect(config.memory.v2.bm25_b).toBe(0.4);
   });
 
+  test("default workspace config merge prunes exact seeded call-site defaults", () => {
+    const seededCallSites = fullSeededCallSites();
+    const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
+    writeFileSync(
+      overlayPath,
+      JSON.stringify(
+        {
+          gateway: {
+            unmappedPolicy: "default",
+            defaultAssistantId: "self",
+          },
+          llm: {
+            activeProfile: "balanced",
+            advisorProfile: "frontier",
+            callSites: {
+              ...seededCallSites,
+              recall: {
+                ...seededCallSites.recall,
+                disableCache: false,
+              },
+              customSite: { profile: "frontier" },
+            },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
+
+    const result = mergeDefaultWorkspaceConfig();
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8")) as Record<
+      string,
+      Record<string, unknown>
+    >;
+    const llm = raw.llm as Record<string, unknown>;
+    const callSites = llm.callSites as Record<string, Record<string, unknown>>;
+
+    expect(result.hadOverlay).toBe(true);
+    expect(raw.gateway).toEqual({
+      unmappedPolicy: "default",
+      defaultAssistantId: "self",
+    });
+    expect(llm.activeProfile).toBe("balanced");
+    expect(llm.advisorProfile).toBe("frontier");
+    expect(Object.keys(callSites).sort()).toEqual(["customSite", "recall"]);
+    expect(callSites.recall?.disableCache).toBe(false);
+    expect(callSites.customSite).toEqual({ profile: "frontier" });
+  });
+
   test("reloads cached config when config.json is updated externally", () => {
     // Models a CLI subprocess writing twilio.accountSid while the assistant
     // process already has an effective config cached in memory.
@@ -745,7 +853,11 @@ describe("loadConfig startup behavior", () => {
     );
     expect(raw.llm.profiles.frontier.provider).toBe("anthropic");
     expect(raw.llm.profiles.frontier.model).toBe("claude-opus-4-8");
-    expect(raw.llm.profiles["cost-optimized"].provider).toBe("anthropic");
+    // Speed is served by DeepSeek V4 Flash on Fireworks.
+    expect(raw.llm.profiles["cost-optimized"].provider).toBe("fireworks");
+    expect(raw.llm.profiles["cost-optimized"].model).toBe(
+      "accounts/fireworks/models/deepseek-v4-flash",
+    );
   });
 
   test("off-platform managed profiles are overwritten on every boot", () => {
@@ -1591,8 +1703,8 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
 // ---------------------------------------------------------------------------
 // Tests: OS Beta flag-gated managed profile. The template is defined but
 // intentionally NOT part of MANAGED_PROFILE_TEMPLATES, so seedInferenceProfiles
-// must never create it. A later PR reconciles it in/out based on the `os-beta`
-// feature flag.
+// must never create it. The flag-gated reconcile creates or removes it based on
+// the `os-beta` feature flag.
 // ---------------------------------------------------------------------------
 
 describe("OS Beta managed profile template", () => {
@@ -1639,20 +1751,21 @@ describe("OS Beta managed profile template", () => {
     expect(MANAGED_PROFILE_NAMES.has("os-beta")).toBe(true);
   });
 
-  test("materializeProfile honors the explicit OS Beta model", () => {
+  test("materializeProfile resolves OS Beta to the Balanced model with low effort", () => {
     const entry = materializeProfile(
       OS_BETA_PROFILE_TEMPLATE,
-      "fireworks",
-      "fireworks-managed",
+      "together",
+      "together-managed",
     );
 
-    expect(entry.model).toBe("accounts/fireworks/models/glm-5p2");
-    expect(entry.provider_connection).toBe("fireworks-managed");
-    expect(entry.provider).toBe("fireworks");
+    expect(entry.model).toBe("MiniMaxAI/MiniMax-M3");
+    expect(entry.provider_connection).toBe("together-managed");
+    expect(entry.provider).toBe("together");
     expect(entry.label).toBe("OS Beta");
     expect(entry.source).toBe("managed");
     expect(entry.maxTokens).toBe(32000);
-    expect(entry.effort).toBe("high");
+    expect(entry.effort).toBe("low");
     expect(entry.thinking?.enabled).toBe(true);
+    expect(entry.topP).toBe(0.95);
   });
 });

package/src/__tests__/config-schema.test.ts

@@ -120,6 +120,7 @@ describe("AssistantConfigSchema", () => {
       shellDefaultTimeoutSec: 120,
       shellMaxTimeoutSec: 600,
       permissionTimeoutSec: 300,
+      questionResponseTimeoutSec: 1800,
       toolExecutionTimeoutSec: 120,
       providerStreamTimeoutSec: 1800,
       backgroundTurnTimeoutSec: 1800,

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -135,11 +135,11 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     mockOnConversationCreatedCallbacks.length = 0;
   });
 
-  test("emits guardian.question for trusted-contact sessions", () => {
+  test("emits guardian.question for trusted-contact sessions", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext = makeTrustedContactContext();
 
-    const result = bridgeConfirmationRequestToGuardian({
+    const result = await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -160,7 +160,7 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(payload.requesterIdentifier).toBe("@requester");
   });
 
-  test("skips guardian actor sessions (self-approve)", () => {
+  test("skips guardian actor sessions (self-approve)", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext: TrustContext = {
       sourceChannel: "telegram",
@@ -168,7 +168,7 @@ describe("bridgeConfirmationRequestToGuardian", () => {
       guardianExternalUserId: "guardian-1",
     };
 
-    const result = bridgeConfirmationRequestToGuardian({
+    const result = await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -182,14 +182,14 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
-  test("skips unknown actor sessions", () => {
+  test("skips unknown actor sessions", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext: TrustContext = {
       sourceChannel: "telegram",
       trustClass: "unknown",
     };
 
-    const result = bridgeConfirmationRequestToGuardian({
+    const result = await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -203,13 +203,13 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
-  test("skips when guardian identity is missing", () => {
+  test("skips when guardian identity is missing", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext = makeTrustedContactContext({
       guardianExternalUserId: undefined,
     });
 
-    const result = bridgeConfirmationRequestToGuardian({
+    const result = await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -223,13 +223,13 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
-  test("skips when no guardian binding exists for channel", () => {
+  test("skips when no guardian binding exists for channel", async () => {
     const canonicalRequest = makeCanonicalRequest({ sourceChannel: "phone" });
     const trustContext = makeTrustedContactContext({
       sourceChannel: "phone",
     });
 
-    const result = bridgeConfirmationRequestToGuardian({
+    const result = await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -243,11 +243,11 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
-  test("sets correct attention hints for urgency", () => {
+  test("sets correct attention hints for urgency", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext = makeTrustedContactContext();
 
-    bridgeConfirmationRequestToGuardian({
+    await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -261,11 +261,11 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(hints.visibleInSourceNow).toBe(false);
   });
 
-  test("uses dedupe key scoped to canonical request ID", () => {
+  test("uses dedupe key scoped to canonical request ID", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext = makeTrustedContactContext();
 
-    bridgeConfirmationRequestToGuardian({
+    await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -277,11 +277,11 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     );
   });
 
-  test("creates vellum delivery row via onConversationCreated callback", () => {
+  test("creates vellum delivery row via onConversationCreated callback", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext = makeTrustedContactContext();
 
-    bridgeConfirmationRequestToGuardian({
+    await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -298,18 +298,20 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     });
 
     const deliveries = listCanonicalGuardianDeliveries(canonicalRequest.id);
-    expect(deliveries).toHaveLength(1);
-    expect(deliveries[0].destinationChannel).toBe("vellum");
-    expect(deliveries[0].destinationConversationId).toBe(
+    const vellumDelivery = deliveries.find(
+      (d) => d.destinationChannel === "vellum",
+    );
+    expect(vellumDelivery).toBeDefined();
+    expect(vellumDelivery?.destinationConversationId).toBe(
       "guardian-conversation-1",
     );
   });
 
-  test("uses custom assistantId when provided", () => {
+  test("uses custom assistantId when provided", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext = makeTrustedContactContext();
 
-    bridgeConfirmationRequestToGuardian({
+    await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -324,13 +326,13 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
-  test("does not pass assistantId to notification signal", () => {
+  test("does not pass assistantId to notification signal", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext = makeTrustedContactContext();
 
     // assistantId is used internally for guardian binding lookup but is no
     // longer forwarded to the notification signal after the assistantId removal refactor.
-    bridgeConfirmationRequestToGuardian({
+    await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -340,13 +342,13 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals[0].assistantId).toBeUndefined();
   });
 
-  test("includes requesterChatId as null when not provided", () => {
+  test("includes requesterChatId as null when not provided", async () => {
     const canonicalRequest = makeCanonicalRequest();
     const trustContext = makeTrustedContactContext({
       requesterChatId: undefined,
     });
 
-    bridgeConfirmationRequestToGuardian({
+    await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -357,7 +359,7 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(payload.requesterChatId).toBeNull();
   });
 
-  test("skips when binding guardian identity does not match canonical request guardian", () => {
+  test("skips when binding guardian identity does not match canonical request guardian", async () => {
     // Create a canonical request where guardianExternalUserId differs from the
     // binding's guardianExternalUserId ('guardian-1' in the mock).
     const canonicalRequest = makeCanonicalRequest({
@@ -365,7 +367,7 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     });
     const trustContext = makeTrustedContactContext();
 
-    const result = bridgeConfirmationRequestToGuardian({
+    const result = await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",
@@ -379,7 +381,7 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
-  test("does not skip when canonical request guardian identity is null", () => {
+  test("does not skip when canonical request guardian identity is null", async () => {
     // When guardianExternalUserId is null on the canonical request (e.g. desktop
     // flow), the identity check should be skipped and the bridge should proceed.
     const canonicalRequest = makeCanonicalRequest({
@@ -387,7 +389,7 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     });
     const trustContext = makeTrustedContactContext();
 
-    const result = bridgeConfirmationRequestToGuardian({
+    const result = await bridgeConfirmationRequestToGuardian({
       canonicalRequest,
       trustContext,
       conversationId: "conv-1",

package/src/__tests__/consult-deadline.test.ts

@@ -0,0 +1,60 @@
+/**
+ * Tests for `createConsultDeadline` — the advisor consult's progress-aware
+ * timeout. Uses short real timers with generous (>=3x) margins so a streamed
+ * chunk reliably lands inside the idle window without timing flakiness.
+ */
+import { describe, expect, test } from "bun:test";
+
+import { createConsultDeadline } from "../tools/subagent/consult-deadline.js";
+
+const delay = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+describe("createConsultDeadline", () => {
+  test("streamed progress keeps the consult alive past the idle window", async () => {
+    // Record progress every 25ms against a 150ms idle window (6x margin). Each
+    // chunk resets the window, so it must never abort over ~200ms of streaming.
+    const d = createConsultDeadline({ idleMs: 150, maxMs: 10_000 });
+    try {
+      for (let i = 0; i < 8; i++) {
+        await delay(25);
+        expect(d.signal.aborted).toBe(false);
+        d.recordProgress();
+      }
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("aborts after the idle window once progress stops", async () => {
+    const d = createConsultDeadline({ idleMs: 50, maxMs: 10_000 });
+    try {
+      expect(d.signal.aborted).toBe(false);
+      await delay(250); // 5x the idle window with no progress
+      expect(d.signal.aborted).toBe(true);
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("aborts at the absolute max even under steady progress", async () => {
+    // Idle window can't fire (huge); the short max must, despite steady chunks.
+    const d = createConsultDeadline({ idleMs: 10_000, maxMs: 70 });
+    try {
+      for (let i = 0; i < 8; i++) {
+        await delay(25);
+        d.recordProgress();
+      }
+      expect(d.signal.aborted).toBe(true); // ~200ms elapsed > 70ms max
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("dispose() cancels both timers — no late abort", async () => {
+    const d = createConsultDeadline({ idleMs: 40, maxMs: 40 });
+    d.dispose();
+    await delay(150); // well past both windows
+    expect(d.signal.aborted).toBe(false);
+  });
+});