@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/config/schemas/__tests__/live-voice.test.ts

@@ -3,9 +3,28 @@ import { describe, expect, test } from "bun:test";
 import {
   LiveVoiceConfigSchema,
   LiveVoiceFluxConfigSchema,
+  LiveVoiceFrontModelConfigSchema,
   LiveVoiceVadConfigSchema,
+  VALID_LIVE_VOICE_MODES,
 } from "../live-voice.js";
 
+const PROGRESS_DEFAULTS = {
+  enabled: true,
+  opsThreshold: 3,
+  idleIntervalMs: 5_000,
+  maxSilenceMs: 35_000,
+  longOpMs: 15_000,
+  minGapMs: 6_000,
+  generationTimeoutMs: 1_500,
+};
+
+const FRONT_MODEL_DEFAULTS = {
+  endpointDecisionTimeoutMs: 1200,
+  endpointExtensionMs: 1500,
+  endpointMaxExtensions: 2,
+  progress: PROGRESS_DEFAULTS,
+};
+
 // `eagerEotThreshold` is deliberately absent: it has no default, and leaving it
 // unset is what keeps Deepgram from emitting speculative turn events. `model`
 // is absent for a related reason: unset means the spoken language selects the
@@ -111,6 +130,117 @@ describe("LiveVoiceVadConfigSchema", () => {
   });
 });
 
+describe("LiveVoiceFrontModelConfigSchema", () => {
+  test("empty object parses to defaults", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({});
+    expect(parsed).toEqual(FRONT_MODEL_DEFAULTS);
+  });
+
+  test("accepts overrides", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      endpointDecisionTimeoutMs: 400,
+      endpointMaxExtensions: 0,
+    });
+    expect(parsed.endpointDecisionTimeoutMs).toBe(400);
+    expect(parsed.endpointMaxExtensions).toBe(0);
+    // Unspecified fields still get defaults
+    expect(parsed.endpointExtensionMs).toBe(1500);
+  });
+
+  test("strips retired generated-ack settings", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      ackFirstDeltaTimeoutMs: 2500,
+      ackGenerationTimeoutMs: 600,
+    });
+    expect(parsed).not.toHaveProperty("ackFirstDeltaTimeoutMs");
+    expect(parsed).not.toHaveProperty("ackGenerationTimeoutMs");
+  });
+
+  test("rejects non-positive endpointDecisionTimeoutMs", () => {
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      endpointDecisionTimeoutMs: 0,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects negative endpointMaxExtensions", () => {
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      endpointMaxExtensions: -1,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("absent progress namespace parses to full progress defaults", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({});
+    expect(parsed.progress).toEqual(PROGRESS_DEFAULTS);
+  });
+
+  test("partial progress overrides merge with defaults", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      progress: { enabled: false, opsThreshold: 5 },
+    });
+    expect(parsed.progress.enabled).toBe(false);
+    expect(parsed.progress.opsThreshold).toBe(5);
+    // Unspecified progress fields still get defaults
+    expect(parsed.progress.idleIntervalMs).toBe(5_000);
+    expect(parsed.progress.maxSilenceMs).toBe(35_000);
+    expect(parsed.progress.longOpMs).toBe(15_000);
+    expect(parsed.progress.minGapMs).toBe(6_000);
+    expect(parsed.progress.generationTimeoutMs).toBe(1_500);
+  });
+
+  test("a stale maxPerTurn key is stripped, not rejected", () => {
+    // The cap was removed; configs written while it existed must still parse.
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      progress: { maxPerTurn: 3 },
+    });
+    expect("maxPerTurn" in parsed.progress).toBe(false);
+  });
+
+  test("rejects non-positive progress.opsThreshold", () => {
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      progress: { opsThreshold: 0 },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects a heartbeat ceiling shorter than the idle tick interval", () => {
+    // The heartbeat is only checked on the idle tick, so a shorter ceiling
+    // could be overshot by a full interval.
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      progress: { idleIntervalMs: 60_000, maxSilenceMs: 10_000 },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((issue) => issue.message);
+      expect(
+        msgs.some((msg) =>
+          msg.includes("liveVoice.frontModel.progress.maxSilenceMs"),
+        ),
+      ).toBe(true);
+    }
+    // The floor itself is allowed: the tick is exactly on the ceiling.
+    expect(
+      LiveVoiceFrontModelConfigSchema.safeParse({
+        progress: { idleIntervalMs: 60_000, maxSilenceMs: 60_000 },
+      }).success,
+    ).toBe(true);
+  });
+
+  test("rejects a non-boolean progress.enabled", () => {
+    const result = LiveVoiceFrontModelConfigSchema.safeParse({
+      progress: { enabled: "yes" },
+    });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((i) => i.message);
+      expect(
+        msgs.some((m) => m.includes("liveVoice.frontModel.progress.enabled")),
+      ).toBe(true);
+    }
+  });
+});
+
 describe("LiveVoiceFluxConfigSchema", () => {
   test("empty object parses to defaults, with turn-end on", () => {
     expect(LiveVoiceFluxConfigSchema.parse({})).toEqual(FLUX_DEFAULTS);
@@ -196,6 +326,7 @@ describe("LiveVoiceConfigSchema", () => {
   test("empty object parses to defaults", () => {
     const parsed = LiveVoiceConfigSchema.parse({});
     expect(parsed).toEqual({
+      mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
         noiseFloorMargin: 3,
@@ -206,9 +337,11 @@ describe("LiveVoiceConfigSchema", () => {
         echoEmaHalfLifeMs: 400,
         echoDrainSlackMs: 300,
       },
+      frontModel: FRONT_MODEL_DEFAULTS,
       // Off by default: Flux turn detection is opt-in, so the front-door hold
       // verdict keeps committing turns until it is enabled.
       flux: FLUX_DEFAULTS,
+      maxSessionDurationSeconds: 1800,
       // Off by default: voice turns carry only their transcript, no audio
       // artifacts on the conversation messages (JARVIS-1283).
       archiveAudio: false,
@@ -232,26 +365,43 @@ describe("LiveVoiceConfigSchema", () => {
 
   test("accepts overrides", () => {
     const parsed = LiveVoiceConfigSchema.parse({
+      mode: "ptt",
       vad: { silenceThresholdMs: 900 },
+      frontModel: { endpointDecisionTimeoutMs: 300 },
       flux: { turnEnd: { enabled: true } },
+      maxSessionDurationSeconds: 600,
     });
+    expect(parsed.mode).toBe("ptt");
     expect(parsed.vad.silenceThresholdMs).toBe(900);
     // Unspecified vad fields still get defaults
     expect(parsed.vad.speechEnergyThreshold).toBe(800);
     expect(parsed.vad.maxTurnDurationMs).toBe(30_000);
+    // Partial frontModel overrides merge with defaults
+    expect(parsed.frontModel.endpointDecisionTimeoutMs).toBe(300);
+    expect(parsed.frontModel.endpointExtensionMs).toBe(1500);
     // Partial flux overrides merge with defaults
     expect(parsed.flux.turnEnd.enabled).toBe(true);
     expect(parsed.flux.eotThreshold).toBe(0.7);
+    expect(parsed.maxSessionDurationSeconds).toBe(600);
   });
 
-  test("persisted configs carrying retired keys keep parsing", () => {
-    // Zod strips unrecognized keys, so a persisted config that still carries
-    // `mode` or `maxSessionDurationSeconds` parses.
-    const parsed = LiveVoiceConfigSchema.parse({
-      mode: "ptt",
-      maxSessionDurationSeconds: 600,
+  test("rejects invalid mode", () => {
+    const result = LiveVoiceConfigSchema.safeParse({ mode: "always-on" });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const msgs = result.error.issues.map((i) => i.message);
+      expect(msgs.some((m) => m.includes("liveVoice.mode"))).toBe(true);
+    }
+  });
+
+  test("rejects non-positive maxSessionDurationSeconds", () => {
+    const result = LiveVoiceConfigSchema.safeParse({
+      maxSessionDurationSeconds: -1,
     });
-    expect(parsed).not.toHaveProperty("mode");
-    expect(parsed).not.toHaveProperty("maxSessionDurationSeconds");
+    expect(result.success).toBe(false);
+  });
+
+  test("VALID_LIVE_VOICE_MODES lists ptt and open-mic", () => {
+    expect(VALID_LIVE_VOICE_MODES).toEqual(["ptt", "open-mic"]);
   });
 });

package/src/config/schemas/calls.ts

@@ -26,8 +26,32 @@ const CallsDisclosureConfigSchema = z
     "Controls whether and how the assistant discloses its nature at the start of a phone call",
   );
 
+const CallsSafetyConfigSchema = z
+  .object({
+    denyCategories: z
+      .array(
+        z.string({
+          error: "calls.safety.denyCategories values must be strings",
+        }),
+      )
+      .default([])
+      .describe(
+        "Categories of calls that should be denied (e.g. for safety or compliance reasons)",
+      ),
+  })
+  .describe("Safety guardrails for phone calls");
+
 const CallsVoiceConfigSchema = z
   .object({
+    interruptSensitivity: z
+      .enum(["low", "medium", "high"], {
+        error:
+          "calls.voice.interruptSensitivity must be one of: low, medium, high",
+      })
+      .default("low")
+      .describe(
+        "How aggressively the STT provider detects the start of caller speech — low reduces false interrupts from background noise",
+      ),
     telephonyStreaming: z
       .boolean({
         error: "calls.voice.telephonyStreaming must be a boolean",
@@ -203,6 +227,7 @@ export const CallsConfigSchema = z
     disclosure: CallsDisclosureConfigSchema.default(
       CallsDisclosureConfigSchema.parse({}),
     ),
+    safety: CallsSafetyConfigSchema.default(CallsSafetyConfigSchema.parse({})),
     voice: CallsVoiceConfigSchema.default(CallsVoiceConfigSchema.parse({})),
     callerIdentity: CallerIdentityConfigSchema.default(
       CallerIdentityConfigSchema.parse({}),
@@ -211,4 +236,6 @@ export const CallsConfigSchema = z
       CallsVerificationConfigSchema.parse({}),
     ),
   })
-  .describe("Phone call configuration: telephony, voice, and call behavior");
+  .describe(
+    "Phone call configuration — controls telephony, voice, safety, and call behavior",
+  );

package/src/config/schemas/live-voice.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 
+export const VALID_LIVE_VOICE_MODES = ["ptt", "open-mic"] as const;
+
 export const LiveVoiceVadConfigSchema = z
   .object({
     speechEnergyThreshold: z
@@ -77,6 +79,149 @@ export const LiveVoiceVadConfigSchema = z
     "Voice-activity-detection tuning for live voice sessions (open-mic turn segmentation)",
   );
 
+export const LiveVoiceProgressConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({
+        error: "liveVoice.frontModel.progress.enabled must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Speak short progress updates during long-running tool-heavy turns; the opt-out for progress narration",
+      ),
+    opsThreshold: z
+      .number({
+        error: "liveVoice.frontModel.progress.opsThreshold must be a number",
+      })
+      .int("liveVoice.frontModel.progress.opsThreshold must be an integer")
+      .positive(
+        "liveVoice.frontModel.progress.opsThreshold must be a positive integer",
+      )
+      .default(3)
+      .describe(
+        "Narrate after this many tool operations since the last narration",
+      ),
+    idleIntervalMs: z
+      .number({
+        error: "liveVoice.frontModel.progress.idleIntervalMs must be a number",
+      })
+      .int("liveVoice.frontModel.progress.idleIntervalMs must be an integer")
+      .positive(
+        "liveVoice.frontModel.progress.idleIntervalMs must be a positive integer",
+      )
+      .default(5_000)
+      .describe(
+        "How often (ms) a running turn's silence is checked, and so the soonest new tool activity is narrated",
+      ),
+    maxSilenceMs: z
+      .number({
+        error: "liveVoice.frontModel.progress.maxSilenceMs must be a number",
+      })
+      .int("liveVoice.frontModel.progress.maxSilenceMs must be an integer")
+      .positive(
+        "liveVoice.frontModel.progress.maxSilenceMs must be a positive integer",
+      )
+      .default(35_000)
+      .describe(
+        "Heartbeat ceiling (ms): narrate after this much unbroken silence even when nothing new has happened. Evaluated on the idle tick, so its resolution is idleIntervalMs and it must be at least that long",
+      ),
+    longOpMs: z
+      .number({
+        error: "liveVoice.frontModel.progress.longOpMs must be a number",
+      })
+      .int("liveVoice.frontModel.progress.longOpMs must be an integer")
+      .positive(
+        "liveVoice.frontModel.progress.longOpMs must be a positive integer",
+      )
+      .default(15_000)
+      .describe(
+        "A tool operation that ran at least this long (ms) narrates the moment it completes, without waiting for opsThreshold",
+      ),
+    minGapMs: z
+      .number({
+        error: "liveVoice.frontModel.progress.minGapMs must be a number",
+      })
+      .int("liveVoice.frontModel.progress.minGapMs must be an integer")
+      .positive(
+        "liveVoice.frontModel.progress.minGapMs must be a positive integer",
+      )
+      .default(6_000)
+      .describe(
+        "Minimum spacing (ms) from any spoken floor-holder — ack or narration",
+      ),
+    generationTimeoutMs: z
+      .number({
+        error:
+          "liveVoice.frontModel.progress.generationTimeoutMs must be a number",
+      })
+      .int(
+        "liveVoice.frontModel.progress.generationTimeoutMs must be an integer",
+      )
+      .positive(
+        "liveVoice.frontModel.progress.generationTimeoutMs must be a positive integer",
+      )
+      .default(1_500)
+      .describe(
+        "Budget (ms) for LLM-generated progress text — not latency-critical: it speaks into dead air",
+      ),
+  })
+  // The heartbeat is checked when the idle tick finds the turn silent, so a
+  // ceiling shorter than the tick interval would be missed by up to a full
+  // interval — a promise the cadence cannot keep. Rejecting the combination
+  // beats silently overshooting it.
+  .refine((progress) => progress.maxSilenceMs >= progress.idleIntervalMs, {
+    error:
+      "liveVoice.frontModel.progress.maxSilenceMs must be at least idleIntervalMs — the heartbeat is evaluated on the idle tick",
+  })
+  .describe(
+    "Progress-narration tuning for live voice sessions (spoken updates during long-running turns)",
+  );
+
+export const LiveVoiceFrontModelConfigSchema = z
+  .object({
+    endpointDecisionTimeoutMs: z
+      .number({
+        error:
+          "liveVoice.frontModel.endpointDecisionTimeoutMs must be a number",
+      })
+      .int("liveVoice.frontModel.endpointDecisionTimeoutMs must be an integer")
+      .positive(
+        "liveVoice.frontModel.endpointDecisionTimeoutMs must be a positive integer",
+      )
+      .default(1200)
+      .describe(
+        "Hard budget (ms) for the endpoint decision LLM call. This adds to end-of-turn latency when semantic endpointing is on, so keep it as tight as the decider model's real roundtrip allows — measured Haiku roundtrips through the managed proxy run ~670-1130ms (dev), so tighter budgets turn the feature into a fail-open no-op.",
+      ),
+    endpointExtensionMs: z
+      .number({
+        error: "liveVoice.frontModel.endpointExtensionMs must be a number",
+      })
+      .int("liveVoice.frontModel.endpointExtensionMs must be an integer")
+      .positive(
+        "liveVoice.frontModel.endpointExtensionMs must be a positive integer",
+      )
+      .default(1500)
+      .describe(
+        "How long (ms) a 'hold' decision keeps the turn open before turn-end replays",
+      ),
+    endpointMaxExtensions: z
+      .number({
+        error: "liveVoice.frontModel.endpointMaxExtensions must be a number",
+      })
+      .int("liveVoice.frontModel.endpointMaxExtensions must be an integer")
+      .nonnegative(
+        "liveVoice.frontModel.endpointMaxExtensions must be a nonnegative integer",
+      )
+      .default(2)
+      .describe("Cap on consecutive 'hold' extensions per utterance"),
+    progress: LiveVoiceProgressConfigSchema.default(
+      LiveVoiceProgressConfigSchema.parse({}),
+    ),
+  })
+  .describe(
+    "Voice front-door endpointing and long-turn progress narration tuning",
+  );
+
 const LiveVoiceFluxTurnEndConfigSchema = z
   .object({
     enabled: z
@@ -140,10 +285,31 @@ export const LiveVoiceFluxConfigSchema = z
 
 export const LiveVoiceConfigSchema = z
   .object({
+    mode: z
+      .enum(VALID_LIVE_VOICE_MODES, {
+        error: `liveVoice.mode must be one of: ${VALID_LIVE_VOICE_MODES.join(", ")}`,
+      })
+      .default("open-mic")
+      .describe(
+        "Default microphone mode for live voice sessions — hands-free (open-mic) or push-to-talk (ptt)",
+      ),
     vad: LiveVoiceVadConfigSchema.default(LiveVoiceVadConfigSchema.parse({})),
+    frontModel: LiveVoiceFrontModelConfigSchema.default(
+      LiveVoiceFrontModelConfigSchema.parse({}),
+    ),
     flux: LiveVoiceFluxConfigSchema.default(
       LiveVoiceFluxConfigSchema.parse({}),
     ),
+    maxSessionDurationSeconds: z
+      .number({
+        error: "liveVoice.maxSessionDurationSeconds must be a number",
+      })
+      .int("liveVoice.maxSessionDurationSeconds must be an integer")
+      .positive(
+        "liveVoice.maxSessionDurationSeconds must be a positive integer",
+      )
+      .default(1800)
+      .describe("Maximum duration of a single live voice session in seconds"),
     archiveAudio: z
       .boolean({ error: "liveVoice.archiveAudio must be a boolean" })
       .default(false)
@@ -152,9 +318,15 @@ export const LiveVoiceConfigSchema = z
       ),
   })
   .describe(
-    "Live voice (in-app duplex audio) configuration: VAD tuning, Flux turn detection, and audio archiving",
+    "Live voice (in-app duplex audio) configuration — mic mode, VAD tuning, and session limits",
   );
 
 export type LiveVoiceConfig = z.infer<typeof LiveVoiceConfigSchema>;
 export type LiveVoiceVadConfig = z.infer<typeof LiveVoiceVadConfigSchema>;
+export type LiveVoiceFrontModelConfig = z.infer<
+  typeof LiveVoiceFrontModelConfigSchema
+>;
+export type LiveVoiceProgressConfig = z.infer<
+  typeof LiveVoiceProgressConfigSchema
+>;
 export type LiveVoiceFluxConfig = z.infer<typeof LiveVoiceFluxConfigSchema>;

package/src/config/schemas/mcp.ts

@@ -102,7 +102,7 @@ export type McpServerConfig = z.infer<typeof McpServerConfigSchema>;
 export type McpConfig = z.infer<typeof McpConfigSchema>;
 
 /**
- * Who declared a server: the workspace `mcp.json`, which the user owns,
+ * Who declared a server: the workspace `config.json`, which the user owns,
  * or a plugin's `mcp.json`, which its author owns.
  *
  * Deliberately not a schema field. It is resolved from where the entry was

package/src/config/schemas/memory-retrospective.ts

@@ -9,16 +9,6 @@ export const MemoryRetrospectiveConfigSchema = z
         "Whether the memory-retrospective background pass runs. When false, no retrospective is enqueued by any trigger (interval, message count, pre-compaction, scheduled sweep), the scheduled sweep job stops being queued, and any row already queued completes as a no-op. The rest of the memory system (extraction, retrieval, embeddings, `<memory>` injection) is unaffected. Use `memory.enabled` to disable memory as a whole.",
       ),
 
-    skillImprovement: z
-      .boolean({
-        error:
-          "memory.retrospective.skillImprovement must be a boolean",
-      })
-      .default(true)
-      .describe(
-        "Whether retrospectives may discover, refine, and create managed skills from observed procedures. When false, retrospectives still capture ordinary memories through `remember`, but cannot load skill management, search for similar skills, or scaffold managed skills.",
-      ),
-
     timeThresholdMs: z
       .number({
         error: "memory.retrospective.timeThresholdMs must be a number",

package/src/config/schemas/services.ts

@@ -140,11 +140,6 @@ const MondayOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
 
-export const ShopifyOAuthServiceSchema = BaseServiceSchema.extend({
-  mode: ServiceModeSchema.default("your-own"),
-});
-export type ShopifyOAuthService = z.infer<typeof ShopifyOAuthServiceSchema>;
-
 export const StripeLinkOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("your-own"),
 });
@@ -219,9 +214,6 @@ export const ServicesSchema = z.object({
   "monday-oauth": MondayOAuthServiceSchema.default(
     MondayOAuthServiceSchema.parse({}),
   ),
-  "shopify-oauth": ShopifyOAuthServiceSchema.default(
-    ShopifyOAuthServiceSchema.parse({}),
-  ),
   "stripe-link-oauth": StripeLinkOAuthServiceSchema.default(
     StripeLinkOAuthServiceSchema.parse({}),
   ),

package/src/config/schemas/skills.ts

@@ -32,6 +32,20 @@ const SkillsLoadConfigSchema = z
       )
       .default([])
       .describe("Additional directories to search for skill definitions"),
+    watch: z
+      .boolean({ error: "skills.load.watch must be a boolean" })
+      .default(true)
+      .describe(
+        "Whether to watch skill directories for changes and auto-reload",
+      ),
+    watchDebounceMs: z
+      .number({ error: "skills.load.watchDebounceMs must be a number" })
+      .int()
+      .positive()
+      .default(250)
+      .describe(
+        "Debounce delay in milliseconds for skill file change detection",
+      ),
   })
   .describe("Controls how skills are discovered and loaded");
 

package/src/credential-execution/process-manager.test.ts

@@ -12,15 +12,8 @@ import {
   test,
 } from "bun:test";
 
-import { waitFor } from "../__tests__/helpers/wait-for.js";
 import { createCesProcessManager } from "./process-manager.js";
 
-const untilClosed = (predicate: () => boolean) =>
-  waitFor(predicate, {
-    timeoutMs: 2000,
-    message: "socket close never propagated to the transport",
-  });
-
 // ---------------------------------------------------------------------------
 // onTransportClose tests
 // ---------------------------------------------------------------------------
@@ -86,7 +79,10 @@ describe("CesProcessManager.onTransportClose", () => {
       sock.destroy();
     }
 
-    await untilClosed(() => closeFired);
+    // Give the close event a tick to propagate.
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(closeFired).toBe(true);
     expect(transport.isAlive()).toBe(false);
 
     await pm.stop();
@@ -116,7 +112,8 @@ describe("CesProcessManager.onTransportClose", () => {
     for (const sock of connections) {
       sock.destroy();
     }
-    await untilClosed(() => !transport.isAlive());
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(transport.isAlive()).toBe(false);
 
     // Register handler AFTER transport is already dead.
     let closeFired = false;
@@ -193,12 +190,14 @@ describe("CesProcessManager transport-death logging", () => {
     for (const sock of connections) {
       sock.destroy();
     }
-    await untilClosed(() =>
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(transport.isAlive()).toBe(false);
+
+    expect(
       calls.some(
         (c) => c.level === "warn" && c.msg.includes("died unexpectedly"),
       ),
-    );
-    expect(transport.isAlive()).toBe(false);
+    ).toBe(true);
 
     await pm.stop();
   });
@@ -209,17 +208,19 @@ describe("CesProcessManager transport-death logging", () => {
     await pm.start();
 
     await pm.stop();
-    await untilClosed(() =>
-      calls.some(
-        (c) =>
-          c.level === "debug" && c.msg.includes("CES socket transport closed"),
-      ),
-    );
+    // Let the socket close event propagate after destroy().
+    await new Promise((resolve) => setTimeout(resolve, 50));
 
     expect(
       calls.some(
         (c) => c.level === "warn" && c.msg.includes("died unexpectedly"),
       ),
     ).toBe(false);
+    expect(
+      calls.some(
+        (c) =>
+          c.level === "debug" && c.msg.includes("CES socket transport closed"),
+      ),
+    ).toBe(true);
   });
 });