@vellumai/assistant 0.12.0 → 0.12.1-dev.202609141913.5e16607

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

@@ -3,28 +3,9 @@ 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
@@ -130,117 +111,6 @@ 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);
@@ -326,7 +196,6 @@ describe("LiveVoiceConfigSchema", () => {
   test("empty object parses to defaults", () => {
     const parsed = LiveVoiceConfigSchema.parse({});
     expect(parsed).toEqual({
-      mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
         noiseFloorMargin: 3,
@@ -337,11 +206,9 @@ 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,
@@ -365,43 +232,26 @@ 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("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,
+  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,
     });
-    expect(result.success).toBe(false);
-  });
-
-  test("VALID_LIVE_VOICE_MODES lists ptt and open-mic", () => {
-    expect(VALID_LIVE_VOICE_MODES).toEqual(["ptt", "open-mic"]);
+    expect(parsed).not.toHaveProperty("mode");
+    expect(parsed).not.toHaveProperty("maxSessionDurationSeconds");
   });
 });

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

@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test";
+
+import { VoiceConfigSchema, VoiceFrontModelConfigSchema } from "../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,
+};
+
+describe("VoiceFrontModelConfigSchema", () => {
+  test("empty object parses to defaults", () => {
+    const parsed = VoiceFrontModelConfigSchema.parse({});
+    expect(parsed).toEqual(FRONT_MODEL_DEFAULTS);
+  });
+
+  test("accepts overrides", () => {
+    const parsed = VoiceFrontModelConfigSchema.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 = VoiceFrontModelConfigSchema.parse({
+      ackFirstDeltaTimeoutMs: 2500,
+      ackGenerationTimeoutMs: 600,
+    });
+    expect(parsed).not.toHaveProperty("ackFirstDeltaTimeoutMs");
+    expect(parsed).not.toHaveProperty("ackGenerationTimeoutMs");
+  });
+
+  test("rejects non-positive endpointDecisionTimeoutMs", () => {
+    const result = VoiceFrontModelConfigSchema.safeParse({
+      endpointDecisionTimeoutMs: 0,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("rejects negative endpointMaxExtensions", () => {
+    const result = VoiceFrontModelConfigSchema.safeParse({
+      endpointMaxExtensions: -1,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("absent progress namespace parses to full progress defaults", () => {
+    const parsed = VoiceFrontModelConfigSchema.parse({});
+    expect(parsed.progress).toEqual(PROGRESS_DEFAULTS);
+  });
+
+  test("partial progress overrides merge with defaults", () => {
+    const parsed = VoiceFrontModelConfigSchema.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 = VoiceFrontModelConfigSchema.parse({
+      progress: { maxPerTurn: 3 },
+    });
+    expect("maxPerTurn" in parsed.progress).toBe(false);
+  });
+
+  test("rejects non-positive progress.opsThreshold", () => {
+    const result = VoiceFrontModelConfigSchema.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 = VoiceFrontModelConfigSchema.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("voice.frontModel.progress.maxSilenceMs"),
+        ),
+      ).toBe(true);
+    }
+    // The floor itself is allowed: the tick is exactly on the ceiling.
+    expect(
+      VoiceFrontModelConfigSchema.safeParse({
+        progress: { idleIntervalMs: 60_000, maxSilenceMs: 60_000 },
+      }).success,
+    ).toBe(true);
+  });
+
+  test("rejects a non-boolean progress.enabled", () => {
+    const result = VoiceFrontModelConfigSchema.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("voice.frontModel.progress.enabled")),
+      ).toBe(true);
+    }
+  });
+});
+
+describe("VoiceConfigSchema", () => {
+  test("empty object parses to front-model defaults", () => {
+    expect(VoiceConfigSchema.parse({})).toEqual({
+      frontModel: FRONT_MODEL_DEFAULTS,
+    });
+  });
+
+  test("partial frontModel overrides merge with defaults", () => {
+    const parsed = VoiceConfigSchema.parse({
+      frontModel: { endpointDecisionTimeoutMs: 300 },
+    });
+    expect(parsed.frontModel.endpointDecisionTimeoutMs).toBe(300);
+    expect(parsed.frontModel.endpointExtensionMs).toBe(1500);
+    expect(parsed.frontModel.progress).toEqual(PROGRESS_DEFAULTS);
+  });
+});

package/src/config/schemas/calls.ts

@@ -26,32 +26,8 @@ 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",
@@ -227,7 +203,6 @@ export const CallsConfigSchema = z
     disclosure: CallsDisclosureConfigSchema.default(
       CallsDisclosureConfigSchema.parse({}),
     ),
-    safety: CallsSafetyConfigSchema.default(CallsSafetyConfigSchema.parse({})),
     voice: CallsVoiceConfigSchema.default(CallsVoiceConfigSchema.parse({})),
     callerIdentity: CallerIdentityConfigSchema.default(
       CallerIdentityConfigSchema.parse({}),
@@ -236,6 +211,4 @@ export const CallsConfigSchema = z
       CallsVerificationConfigSchema.parse({}),
     ),
   })
-  .describe(
-    "Phone call configuration — controls telephony, voice, safety, and call behavior",
-  );
+  .describe("Phone call configuration: telephony, voice, and call behavior");

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

@@ -1,7 +1,5 @@
 import { z } from "zod";
 
-export const VALID_LIVE_VOICE_MODES = ["ptt", "open-mic"] as const;
-
 export const LiveVoiceVadConfigSchema = z
   .object({
     speechEnergyThreshold: z
@@ -79,149 +77,6 @@ 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
@@ -285,31 +140,10 @@ 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)
@@ -318,15 +152,9 @@ export const LiveVoiceConfigSchema = z
       ),
   })
   .describe(
-    "Live voice (in-app duplex audio) configuration — mic mode, VAD tuning, and session limits",
+    "Live voice (in-app duplex audio) configuration: VAD tuning, Flux turn detection, and audio archiving",
   );
 
 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 `config.json`, which the user owns,
+ * Who declared a server: the workspace `mcp.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,6 +9,16 @@ 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,6 +140,11 @@ 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"),
 });
@@ -214,6 +219,9 @@ 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,20 +32,6 @@ 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");