@vellumai/assistant 0.7.3 → 0.8.0

package/src/__tests__/cli-memory-v2-reembed-skills.test.ts

@@ -4,9 +4,8 @@
  *
  * The CLI half mocks `cliIpcCall` and asserts the subcommand dispatches
  * to `memory_v2_reembed_skills` with an empty body. The route half uses
- * the real `loadConfig` + flag resolver — flags are toggled via
- * `_setOverridesForTesting` and `memory.v2.enabled` is toggled via a
- * per-test `config.json` fixture in the temp workspace. We mock only
+ * the real `loadConfig` — `memory.v2.enabled` is toggled via a per-test
+ * `config.json` fixture in the temp workspace. We mock only
  * `seedV2SkillEntries` so we can assert it was invoked without actually
  * embedding skills.
  */
@@ -17,20 +16,14 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { Command } from "commander";
 
-import {
-  _setOverridesForTesting,
-  clearFeatureFlagOverridesCache,
-} from "../config/assistant-feature-flags.js";
 import { invalidateConfigCache } from "../config/loader.js";
 import { getWorkspaceDir } from "../util/platform.js";
 
 // ---------------------------------------------------------------------------
-// Module-level mocks — kept minimal. `loadConfig`,
-// `isAssistantFeatureFlagEnabled`, and `getLogger` use their real
-// implementations because we already have first-class test hooks
-// (`_setOverridesForTesting` for flags, a per-test workspace `config.json`
-// for config) that exercise the same code paths the route handler runs in
-// production.
+// Module-level mocks — kept minimal. `loadConfig` and `getLogger` use their
+// real implementations because we have first-class test hooks (a per-test
+// workspace `config.json` for config) that exercise the same code paths
+// the route handler runs in production.
 // ---------------------------------------------------------------------------
 
 let lastIpcCall: { method: string; params?: Record<string, unknown> } | null =
@@ -60,7 +53,7 @@ mock.module("../memory/v2/skill-store.js", () => ({
 
 const { registerMemoryV2Command } =
   await import("../cli/commands/memory-v2.js");
-const { ROUTES: memoryV2Routes } =
+const { ROUTES: memoryV2Routes, MEMORY_V2_DISABLED_CODE } =
   await import("../runtime/routes/memory-v2-routes.js");
 const { RouteError } = await import("../runtime/routes/errors.js");
 
@@ -128,17 +121,15 @@ beforeEach(() => {
   seedCallCount = 0;
   process.exitCode = 0;
 
-  // Real flag + config defaults: enable both so happy-path tests pass.
-  _setOverridesForTesting({ "memory-v2-enabled": true });
+  // Default: v2 enabled so happy-path tests pass.
   writeWorkspaceConfig({ memory: { v2: { enabled: true } } });
 });
 
 afterEach(() => {
-  // Roll back the workspace config + flag overrides between cases so a
-  // gate-off test does not leak into the next case's setup.
+  // Roll back the workspace config between cases so a gate-off test does
+  // not leak into the next case's setup.
   rmSync(join(getWorkspaceDir(), "config.json"), { force: true });
   invalidateConfigCache();
-  clearFeatureFlagOverridesCache();
 });
 
 // ---------------------------------------------------------------------------
@@ -188,15 +179,6 @@ describe("memory_v2_reembed_skills route", () => {
     expect(seedCallCount).toBe(0);
   });
 
-  test("throws RouteError when feature flag is off", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-
-    await expect(
-      reembedSkillsRoute!.handler({ body: {} }),
-    ).rejects.toBeInstanceOf(RouteError);
-    expect(seedCallCount).toBe(0);
-  });
-
   test("throws RouteError when config.memory.v2.enabled is off", async () => {
     writeWorkspaceConfig({ memory: { v2: { enabled: false } } });
 
@@ -206,3 +188,51 @@ describe("memory_v2_reembed_skills route", () => {
     expect(seedCallCount).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// All v2 routes share the same gate
+// ---------------------------------------------------------------------------
+
+describe("all memory v2 routes — MEMORY_V2_DISABLED gate", () => {
+  // Minimal bodies that satisfy each route's schema. The gate runs before
+  // schema validation so any body would surface the gate error, but using
+  // valid shapes keeps the assertion precise: we're confirming the gate
+  // (not zod) is what blocks the call.
+  const MINIMAL_BODIES: Record<string, Record<string, unknown>> = {
+    memory_v2_backfill: { op: "migrate" },
+    memory_v2_validate: {},
+    memory_v2_get_concept_page: { slug: "any" },
+    memory_v2_list_concept_pages: {},
+    memory_v2_rebuild_corpus_stats: {},
+    memory_v2_explain_similarity: { userText: "hello" },
+    memory_v2_concept_frequency: {},
+    memory_v2_fit_anisotropy: {},
+  };
+
+  const GATE_OFF_CASES = [
+    {
+      label: "config is off",
+      apply: () => writeWorkspaceConfig({ memory: { v2: { enabled: false } } }),
+    },
+  ];
+
+  for (const [operationId, body] of Object.entries(MINIMAL_BODIES)) {
+    for (const { label, apply } of GATE_OFF_CASES) {
+      test(`${operationId} throws MEMORY_V2_DISABLED when ${label}`, async () => {
+        apply();
+        const route = memoryV2Routes.find((r) => r.operationId === operationId);
+        expect(route).toBeDefined();
+
+        try {
+          await route!.handler({ body });
+          throw new Error("expected handler to throw");
+        } catch (err) {
+          expect(err).toBeInstanceOf(RouteError);
+          expect((err as InstanceType<typeof RouteError>).code).toBe(
+            MEMORY_V2_DISABLED_CODE,
+          );
+        }
+      });
+    }
+  }
+});

package/src/__tests__/config-loader-platform-defaults.test.ts

@@ -58,6 +58,7 @@ afterAll(() => {
 });
 
 import { invalidateConfigCache, loadConfig } from "../config/loader.js";
+import { applyContextDefaultsToRawConfig } from "../runtime/routes/conversation-query-routes.js";
 import { _setStorePath } from "../security/encrypted-store.js";
 
 // ---------------------------------------------------------------------------
@@ -184,7 +185,7 @@ describe("platform-managed config defaults", () => {
       ) + "\n",
     );
 
-    loadConfig();
+    const config = loadConfig();
 
     const written = readConfig() as { services?: Record<string, unknown> };
     expect(written.services).toBeDefined();
@@ -192,5 +193,287 @@ describe("platform-managed config defaults", () => {
     expect(
       (written.services!["inference"] as { mode?: string })?.mode,
     ).toBe("your-own");
+    // ...and the in-memory config must mirror the explicit user choice (the
+    // fill-defaults pass must not override an explicit "your-own").
+    expect(
+      (config.services.inference as { mode: string }).mode,
+    ).toBe("your-own");
+  });
+
+  test("IS_PLATFORM=true, config file exists without a services key → in-memory config has all managed modes", () => {
+    // Regression guard for the platform-managed boot order: by the time
+    // `loadConfig()` runs, lifecycle steps such as `seedInferenceProfiles`
+    // have already written `config.json` (with `llm.profiles` etc.), so
+    // `configFileExisted` is true even on a brand-new platform-managed
+    // assistant. Deployment-context defaults must still be applied to the
+    // in-memory config for any leaf keys that are absent from disk.
+    process.env.IS_PLATFORM = "true";
+
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          llm: {
+            profiles: {
+              balanced: { provider: "anthropic", model: "claude-sonnet-4.5" },
+            },
+            activeProfile: "balanced",
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const config = loadConfig();
+
+    // In-memory config has the deployment-context defaults applied for the
+    // missing service-mode fields.
+    for (const svc of MANAGED_SERVICES) {
+      expect(
+        (
+          config.services as unknown as Record<
+            string,
+            { mode: string }
+          >
+        )[svc]!.mode,
+      ).toBe("managed");
+    }
+
+    // The on-disk file is NOT modified by the fill pass — disk reflects only
+    // what was already there. Existing-file branch never re-writes config.json.
+    const onDisk = readConfig() as Record<string, unknown>;
+    expect(onDisk["services"]).toBeUndefined();
+  });
+
+  test("IS_PLATFORM=true, config file exists with a partial service subtree → preserves user fields, fills missing mode", () => {
+    process.env.IS_PLATFORM = "true";
+
+    // User has an image-generation provider configured but never explicitly
+    // chose a mode for that service. The fill pass must apply
+    // `mode: "managed"` without clobbering the user-supplied provider.
+    // (The inference schema dropped per-service model/provider in
+    // migration 039 — image-generation still carries them, so it's the
+    // right schema to exercise the partial-subtree case.)
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          services: {
+            "image-generation": { provider: "openai" },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const config = loadConfig();
+
+    const imageGen = (
+      config.services as unknown as Record<
+        string,
+        { mode: string; provider?: string }
+      >
+    )["image-generation"]!;
+    expect(imageGen.mode).toBe("managed");
+    expect(imageGen.provider).toBe("openai");
+  });
+
+  test("IS_PLATFORM=false, config file exists without services key → in-memory config keeps schema your-own defaults", () => {
+    // Sanity guard: deployment-context defaults are a no-op when IS_PLATFORM
+    // is not enabled, regardless of whether config.json existed.
+    process.env.IS_PLATFORM = "false";
+
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          llm: {
+            profiles: {
+              balanced: { provider: "anthropic", model: "claude-sonnet-4.5" },
+            },
+            activeProfile: "balanced",
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    const config = loadConfig();
+
+    for (const svc of MANAGED_SERVICES) {
+      expect(
+        (
+          config.services as unknown as Record<
+            string,
+            { mode: string }
+          >
+        )[svc]!.mode,
+      ).toBe("your-own");
+    }
+  });
+});
+
+/**
+ * Regression guard for the `handleGetConfig` route handler in
+ * `assistant/src/runtime/routes/conversation-query-routes.ts`. That handler
+ * returns the raw on-disk JSON to clients (macOS, web, CLI) via
+ * `GET /v1/config`, but first layers deployment-context defaults on top
+ * via the `applyContextDefaultsToRawConfig` helper.
+ *
+ * macOS's `loadServiceModes(config:)` only updates `inferenceMode` when
+ * `services.inference.mode` is present in the response — without the fill
+ * pass, freshly-hatched platform-managed assistants would have no `services`
+ * key on disk (only `llm.profiles` from `seedInferenceProfiles`) and macOS
+ * would fall back to its `@Published` default of "your-own". The helper is
+ * also responsible for guarding against `loadRawConfig()` returning a
+ * non-object payload from a malformed-but-parseable `config.json`.
+ */
+describe("GET /v1/config handler — context-default fill on raw response", () => {
+  const originalIsPlatform = process.env.IS_PLATFORM;
+
+  afterEach(() => {
+    if (originalIsPlatform === undefined) {
+      delete process.env.IS_PLATFORM;
+    } else {
+      process.env.IS_PLATFORM = originalIsPlatform;
+    }
+  });
+
+  test("IS_PLATFORM=true, raw config has no services key → response includes managed defaults", () => {
+    process.env.IS_PLATFORM = "true";
+
+    // Mirrors the real-world fresh-hatch state: lifecycle wrote
+    // `llm.profiles` to disk, but never persisted any service modes.
+    const raw: Record<string, unknown> = {
+      llm: {
+        profiles: {
+          balanced: { provider: "anthropic", model: "claude-sonnet-4.5" },
+        },
+        activeProfile: "balanced",
+      },
+    };
+
+    const result = applyContextDefaultsToRawConfig(raw) as Record<
+      string,
+      unknown
+    >;
+    const services = result["services"] as Record<string, { mode: string }>;
+    expect(services).toBeDefined();
+    for (const svc of MANAGED_SERVICES) {
+      expect(services[svc]!.mode).toBe("managed");
+    }
+  });
+
+  test("IS_PLATFORM=true, raw config has explicit services.inference.mode='your-own' → preserved", () => {
+    process.env.IS_PLATFORM = "true";
+
+    // User has explicitly chosen "your-own" via the macOS Save flow.
+    // The patch handler persisted that to disk; the fill pass must not
+    // override an explicit user choice.
+    const raw: Record<string, unknown> = {
+      services: {
+        inference: { mode: "your-own" },
+      },
+    };
+
+    const result = applyContextDefaultsToRawConfig(raw) as Record<
+      string,
+      unknown
+    >;
+    const services = result["services"] as Record<string, { mode: string }>;
+    expect(services["inference"]!.mode).toBe("your-own");
+    // Other services were missing entirely → context defaults fill them in.
+    expect(services["image-generation"]!.mode).toBe("managed");
+    expect(services["web-search"]!.mode).toBe("managed");
+  });
+
+  test("IS_PLATFORM=false, raw config has no services key → response is unchanged", () => {
+    process.env.IS_PLATFORM = "false";
+
+    const raw: Record<string, unknown> = {
+      llm: {
+        profiles: {
+          balanced: { provider: "anthropic", model: "claude-sonnet-4.5" },
+        },
+      },
+    };
+
+    const result = applyContextDefaultsToRawConfig(raw) as Record<
+      string,
+      unknown
+    >;
+    expect(result["services"]).toBeUndefined();
+  });
+
+  test("IS_PLATFORM=true, raw config has partial services.inference subtree → preserves user fields, fills missing mode", () => {
+    process.env.IS_PLATFORM = "true";
+
+    // User set image-generation.provider but never chose a mode for any
+    // service. The fill pass adds the missing modes without clobbering
+    // the user-supplied provider.
+    const raw: Record<string, unknown> = {
+      services: {
+        "image-generation": { provider: "openai" },
+      },
+    };
+
+    const result = applyContextDefaultsToRawConfig(raw) as Record<
+      string,
+      unknown
+    >;
+    const services = result["services"] as Record<
+      string,
+      { mode: string; provider?: string }
+    >;
+    expect(services["image-generation"]!.mode).toBe("managed");
+    expect(services["image-generation"]!.provider).toBe("openai");
+    // Inference, which was missing entirely, picks up the context default.
+    expect(services["inference"]!.mode).toBe("managed");
+  });
+
+  // -------------------------------------------------------------------------
+  // Malformed-but-parseable config.json — must not 500 the GET endpoint.
+  //
+  // `loadRawConfig()` is typed `Record<string, unknown>` but `JSON.parse`
+  // will happily return `null`, primitives, or arrays for a syntactically
+  // valid file like `null` / `42` / `[]`. The helper must return those
+  // payloads unchanged rather than throwing inside
+  // `fillContextDefaultsForMissingKeys`.
+  // -------------------------------------------------------------------------
+
+  test("IS_PLATFORM=true, raw config is null → returned unchanged (no throw)", () => {
+    process.env.IS_PLATFORM = "true";
+    expect(applyContextDefaultsToRawConfig(null)).toBe(null);
+  });
+
+  test("IS_PLATFORM=true, raw config is a primitive number → returned unchanged (no throw)", () => {
+    process.env.IS_PLATFORM = "true";
+    expect(applyContextDefaultsToRawConfig(42)).toBe(42);
+  });
+
+  test("IS_PLATFORM=true, raw config is an array → returned unchanged (no throw)", () => {
+    process.env.IS_PLATFORM = "true";
+    const raw: unknown[] = [{ foo: "bar" }];
+    const result = applyContextDefaultsToRawConfig(raw);
+    expect(result).toBe(raw);
+    // No `services` key was synthesized onto the array.
+    expect((result as { services?: unknown }).services).toBeUndefined();
+  });
+
+  test("IS_PLATFORM=true, raw config is a string → returned unchanged (no throw)", () => {
+    process.env.IS_PLATFORM = "true";
+    expect(applyContextDefaultsToRawConfig("not-an-object")).toBe(
+      "not-an-object",
+    );
+  });
+
+  test("IS_PLATFORM=false, raw config is null → returned unchanged (no throw)", () => {
+    // Sanity check: when there are no context defaults to apply, the helper
+    // also short-circuits cleanly on non-object payloads.
+    process.env.IS_PLATFORM = "false";
+    expect(applyContextDefaultsToRawConfig(null)).toBe(null);
   });
 });

package/src/__tests__/context-search-memory-source.test.ts

@@ -1,6 +1,5 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import type {
   RecallEvidence,
@@ -107,11 +106,7 @@ const v2Calls: Array<{
 }> = [];
 let v2EvidenceReturn: RecallEvidence[] = [];
 
-const realMemoryV2 =
-  await import("../memory/context-search/sources/memory-v2.js");
-
 mock.module(memoryV2SourceModule, () => ({
-  isMemoryV2ReadActive: realMemoryV2.isMemoryV2ReadActive,
   searchMemoryV2Source: async (
     query: string,
     context: RecallSearchContext,
@@ -138,7 +133,6 @@ describe("searchMemorySource", () => {
     getNodesByIdsCalls.length = 0;
     v2Calls.length = 0;
     v2EvidenceReturn = [];
-    _setOverridesForTesting({ "memory-v2-enabled": false });
   });
 
   test("hydrates graph hits into memory recall evidence", async () => {
@@ -298,8 +292,7 @@ describe("searchMemorySource", () => {
     );
   });
 
-  test("routes to v2 source when both v2 gates are on", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("routes to v2 source when memory.v2.enabled is on", async () => {
     v2EvidenceReturn = [
       {
         id: "memory:v2:alice",
@@ -334,8 +327,7 @@ describe("searchMemorySource", () => {
     ]);
   });
 
-  test("stays on legacy path when feature flag is on but config.memory.v2.enabled is off", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("stays on legacy path when memory.v2.enabled is off", async () => {
     searchHits = [{ nodeId: "node-a", score: 0.7, text: "" }];
     hydratedNodes = [makeNode({ id: "node-a", content: "Legacy hit" })];
 
@@ -348,21 +340,6 @@ describe("searchMemorySource", () => {
     expect(v2Calls).toHaveLength(0);
     expect(searchCalls).toHaveLength(1);
   });
-
-  test("stays on legacy path when feature flag is off", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    searchHits = [{ nodeId: "node-a", score: 0.7, text: "" }];
-    hydratedNodes = [makeNode({ id: "node-a", content: "Legacy hit" })];
-
-    await searchMemorySource(
-      "alice",
-      makeContext({ config: makeV2EnabledConfig() }),
-      5,
-    );
-
-    expect(v2Calls).toHaveLength(0);
-    expect(searchCalls).toHaveLength(1);
-  });
 });
 
 function makeV2EnabledConfig(): AssistantConfig {
@@ -387,7 +364,7 @@ function makeContext(
   return {
     workingDir: "/tmp/example-workspace",
     conversationId: "conv-123",
-    config: {} as AssistantConfig,
+    config: { memory: { v2: { enabled: false } } } as AssistantConfig,
     ...overrides,
   };
 }

package/src/__tests__/context-search-pkb-source.test.ts

@@ -9,7 +9,6 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import type { RecallSearchContext } from "../memory/context-search/types.js";
 import { PKB_WORKSPACE_SCOPE } from "../memory/pkb/types.js";
@@ -19,6 +18,16 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
 
+// Override `getConfig` so `searchPkbFiles`'s v2 short-circuit (which checks
+// `getConfig().memory.v2.enabled`) stays inactive — these tests exercise
+// the v1 path. Spread the real loader so other exports (loadConfig,
+// applyNestedDefaults, etc.) keep working.
+const realPkbLoader = await import("../config/loader.js");
+mock.module("../config/loader.js", () => ({
+  ...realPkbLoader,
+  getConfig: () => ({ memory: { v2: { enabled: false } } }),
+}));
+
 const embedCalls: Array<{
   config: AssistantConfig;
   texts: unknown[];
@@ -174,7 +183,7 @@ function makeContext(
   return {
     workingDir: "/workspace",
     conversationId: "conv-xyz",
-    config: {} as AssistantConfig,
+    config: { memory: { v2: { enabled: false } } } as AssistantConfig,
     ...overrides,
   };
 }
@@ -193,7 +202,6 @@ describe("PKB context-search source", () => {
     denseThrows = null;
     pkbContext = null;
     nowScratchpad = null;
-    _setOverridesForTesting({ "memory-v2-enabled": false });
   });
 
   test("converts PKB hits to recall evidence with snippets and scores", async () => {
@@ -443,8 +451,7 @@ describe("PKB context-search source", () => {
     ]);
   });
 
-  test("short-circuits to empty when both v2 gates are on", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("short-circuits to empty when memory.v2.enabled is on", async () => {
     denseResults = [
       {
         id: "dense-a",
@@ -471,7 +478,6 @@ describe("PKB context-search source", () => {
   });
 
   test("readPkbContextEvidence short-circuits when v2 read is active", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     pkbContext = "should not surface under v2";
     nowScratchpad = "should not surface under v2";
 

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -1,18 +1,12 @@
 import { describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type {
   ContentBlock,
   Message,
   ProviderResponse,
 } from "../providers/types.js";
 
-// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
-// (registry default `true`) flips memory routing to v2 — disable it here so
-// the v1 paths under test stay active.
-_setOverridesForTesting({ "memory-v2-enabled": false });
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
@@ -61,6 +55,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -476,7 +476,7 @@ function makeCtx(
     }),
 
     graphMemory: {
-      onCompacted: () => {},
+      onCompacted: async () => {},
       prepareMemory: async () => ({
         runMessages: [],
         injectedTokens: 0,

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -531,7 +531,7 @@ function makeCtx(
     }),
 
     graphMemory: {
-      onCompacted: () => {},
+      onCompacted: async () => {},
       prepareMemory: async () => ({
         runMessages: [],
         injectedTokens: 0,

package/src/__tests__/conversation-agent-loop.test.ts

@@ -626,7 +626,7 @@ function makeCtx(
     }),
 
     graphMemory: {
-      onCompacted: () => {},
+      onCompacted: async () => {},
       prepareMemory: async () => ({
         runMessages: [],
         injectedTokens: 0,
@@ -3652,11 +3652,11 @@ describe("session-agent-loop", () => {
       expect(rendered).not.toContain("original root");
     });
 
-    test("applyCompactionResult records Slack timestamp watermark when provided", () => {
+    test("applyCompactionResult records Slack timestamp watermark when provided", async () => {
       const ctx = makeCtx();
       const events: ServerMessage[] = [];
 
-      applyCompactionResult(
+      await applyCompactionResult(
         ctx,
         {
           messages: [

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -280,21 +280,13 @@ function seedPendingConfirmation(
   conversation: Conversation,
   requestId: string,
 ): void {
+  // Access private ownedIds so denyAllPending/dispose can find this request.
+  // promptResolve/promptReject callbacks are stored in pendingInteractions via
+  // registerPendingInteraction, which is called separately in each test.
   const prompter = conversation["prompter"] as unknown as {
-    pending: Map<
-      string,
-      {
-        resolve: (...args: unknown[]) => void;
-        reject: (...args: unknown[]) => void;
-        timer: ReturnType<typeof setTimeout>;
-      }
-    >;
+    ownedIds: Set<string>;
   };
-  prompter.pending.set(requestId, {
-    resolve: () => {},
-    reject: () => {},
-    timer: setTimeout(() => {}, 60_000),
-  });
+  prompter.ownedIds.add(requestId);
 }
 
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -465,7 +465,7 @@ describe("End-to-end session creation benchmark", () => {
       timings.push(performance.now() - start);
 
       if (i === 0) {
-        expect(session.eventBus.listenerCount()).toBeGreaterThan(0);
+        expect(session.eventBus.anyListenerCount()).toBeGreaterThan(0);
       }
       session.dispose();
     }