@vellumai/assistant 0.12.1-staging.1 → 0.12.1

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/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);
   });
 });