@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

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

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   LiveVoiceConfigSchema,
+  LiveVoiceFluxConfigSchema,
   LiveVoiceFrontModelConfigSchema,
   LiveVoiceVadConfigSchema,
   VALID_LIVE_VOICE_MODES,
@@ -21,11 +22,18 @@ const FRONT_MODEL_DEFAULTS = {
   endpointDecisionTimeoutMs: 1200,
   endpointExtensionMs: 1500,
   endpointMaxExtensions: 2,
-  ackFirstDeltaTimeoutMs: 2500,
-  ackGenerationTimeoutMs: 600,
   progress: PROGRESS_DEFAULTS,
 };
 
+// `eagerEotThreshold` is deliberately absent: it has no default, and leaving it
+// unset is what keeps Deepgram from emitting speculative turn events.
+const FLUX_DEFAULTS = {
+  turnEnd: { enabled: false },
+  model: "flux-general-en",
+  eotThreshold: 0.7,
+  eotTimeoutMs: 5_000,
+};
+
 describe("LiveVoiceVadConfigSchema", () => {
   test("empty object parses to defaults", () => {
     const parsed = LiveVoiceVadConfigSchema.parse({});
@@ -34,6 +42,9 @@ describe("LiveVoiceVadConfigSchema", () => {
       silenceThresholdMs: 1200,
       maxTurnDurationMs: 30_000,
       bargeInMinSpeechMs: 250,
+      echoBargeInMargin: 1.5,
+      echoEmaHalfLifeMs: 400,
+      echoDrainSlackMs: 300,
     });
   });
 
@@ -75,6 +86,35 @@ describe("LiveVoiceVadConfigSchema", () => {
     });
     expect(result.success).toBe(false);
   });
+
+  test("accepts echo gate overrides", () => {
+    const parsed = LiveVoiceVadConfigSchema.parse({
+      echoBargeInMargin: 2.25,
+      echoEmaHalfLifeMs: 250,
+      echoDrainSlackMs: 500,
+    });
+    expect(parsed.echoBargeInMargin).toBe(2.25);
+    expect(parsed.echoEmaHalfLifeMs).toBe(250);
+    expect(parsed.echoDrainSlackMs).toBe(500);
+  });
+
+  test("rejects an echo margin that cannot exceed its reference", () => {
+    expect(
+      LiveVoiceVadConfigSchema.safeParse({ echoBargeInMargin: 1 }).success,
+    ).toBe(false);
+  });
+
+  test("rejects invalid echo timing values", () => {
+    expect(
+      LiveVoiceVadConfigSchema.safeParse({ echoEmaHalfLifeMs: 0 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceVadConfigSchema.safeParse({ echoEmaHalfLifeMs: 250.5 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceVadConfigSchema.safeParse({ echoDrainSlackMs: -1 }).success,
+    ).toBe(false);
+  });
 });
 
 describe("LiveVoiceFrontModelConfigSchema", () => {
@@ -92,8 +132,15 @@ describe("LiveVoiceFrontModelConfigSchema", () => {
     expect(parsed.endpointMaxExtensions).toBe(0);
     // Unspecified fields still get defaults
     expect(parsed.endpointExtensionMs).toBe(1500);
-    expect(parsed.ackFirstDeltaTimeoutMs).toBe(2500);
-    expect(parsed.ackGenerationTimeoutMs).toBe(600);
+  });
+
+  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", () => {
@@ -181,6 +228,87 @@ describe("LiveVoiceFrontModelConfigSchema", () => {
   });
 });
 
+describe("LiveVoiceFluxConfigSchema", () => {
+  test("empty object parses to defaults, with turn-end off", () => {
+    expect(LiveVoiceFluxConfigSchema.parse({})).toEqual(FLUX_DEFAULTS);
+  });
+
+  test("an unset eagerEotThreshold is absent, not zero", () => {
+    expect("eagerEotThreshold" in LiveVoiceFluxConfigSchema.parse({})).toBe(
+      false,
+    );
+  });
+
+  test("accepts overrides", () => {
+    const parsed = LiveVoiceFluxConfigSchema.parse({
+      turnEnd: { enabled: true },
+      model: "flux-general-multi",
+      eotThreshold: 0.85,
+      eagerEotThreshold: 0.45,
+      eotTimeoutMs: 12_000,
+    });
+    expect(parsed.turnEnd.enabled).toBe(true);
+    expect(parsed.model).toBe("flux-general-multi");
+    expect(parsed.eotThreshold).toBe(0.85);
+    expect(parsed.eagerEotThreshold).toBe(0.45);
+    expect(parsed.eotTimeoutMs).toBe(12_000);
+  });
+
+  test("partial overrides merge with defaults", () => {
+    const parsed = LiveVoiceFluxConfigSchema.parse({ eotThreshold: 0.6 });
+    expect(parsed.eotThreshold).toBe(0.6);
+    expect(parsed.turnEnd.enabled).toBe(false);
+    expect(parsed.model).toBe("flux-general-en");
+    expect(parsed.eotTimeoutMs).toBe(5_000);
+  });
+
+  test("rejects an eotThreshold outside 0.5..0.9", () => {
+    const above = LiveVoiceFluxConfigSchema.safeParse({ eotThreshold: 0.95 });
+    expect(above.success).toBe(false);
+    expect(above.error?.issues.map((i) => i.message)).toEqual([
+      "liveVoice.flux.eotThreshold must be <= 0.9",
+    ]);
+
+    const below = LiveVoiceFluxConfigSchema.safeParse({ eotThreshold: 0.4 });
+    expect(below.success).toBe(false);
+    expect(below.error?.issues.map((i) => i.message)).toEqual([
+      "liveVoice.flux.eotThreshold must be >= 0.5",
+    ]);
+  });
+
+  test("rejects an eagerEotThreshold outside 0.3..0.9", () => {
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eagerEotThreshold: 0.2 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eagerEotThreshold: 0.95 }).success,
+    ).toBe(false);
+  });
+
+  test("rejects an eotTimeoutMs outside 500..60000, and non-integers", () => {
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eotTimeoutMs: 499 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eotTimeoutMs: 60_001 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eotTimeoutMs: 1_500.5 }).success,
+    ).toBe(false);
+  });
+
+  test("rejects a non-boolean turnEnd.enabled", () => {
+    const result = LiveVoiceFluxConfigSchema.safeParse({
+      turnEnd: { enabled: "yes" },
+    });
+    expect(result.success).toBe(false);
+    const msgs = result.error?.issues.map((i) => i.message) ?? [];
+    expect(msgs.some((m) => m.includes("liveVoice.flux.turnEnd.enabled"))).toBe(
+      true,
+    );
+  });
+});
+
 describe("LiveVoiceConfigSchema", () => {
   test("empty object parses to defaults", () => {
     const parsed = LiveVoiceConfigSchema.parse({});
@@ -191,8 +319,14 @@ describe("LiveVoiceConfigSchema", () => {
         silenceThresholdMs: 1200,
         maxTurnDurationMs: 30_000,
         bargeInMinSpeechMs: 250,
+        echoBargeInMargin: 1.5,
+        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).
@@ -220,6 +354,7 @@ describe("LiveVoiceConfigSchema", () => {
       mode: "ptt",
       vad: { silenceThresholdMs: 900 },
       frontModel: { endpointDecisionTimeoutMs: 300 },
+      flux: { turnEnd: { enabled: true } },
       maxSessionDurationSeconds: 600,
     });
     expect(parsed.mode).toBe("ptt");
@@ -230,6 +365,9 @@ describe("LiveVoiceConfigSchema", () => {
     // 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);
   });
 

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

@@ -66,11 +66,22 @@ describe("SttServiceSchema", () => {
     );
   });
 
-  test("language is optional and stays absent when unset", () => {
-    // Absent (not defaulted to "en") so the resolver can tell "user chose
-    // nothing" from "user chose English" and omit the param entirely.
+  test("language defaults to multilingual rather than staying absent", () => {
+    // Every config carries a real language, so nothing downstream has to
+    // infer one from an absent key. Omitting the param entirely is not a
+    // neutral state on Deepgram and the managed relay: it decodes as
+    // English, which is what this default exists to stop.
     const parsed = SttServiceSchema.parse({ provider: "vellum" });
-    expect(parsed.language).toBeUndefined();
+    expect(parsed.language).toBe("multi");
+  });
+
+  test("a chosen language is never replaced by the default", () => {
+    expect(
+      SttServiceSchema.parse({ provider: "deepgram", language: "ta" }).language,
+    ).toBe("ta");
+    expect(
+      SttServiceSchema.parse({ provider: "deepgram", language: "en" }).language,
+    ).toBe("en");
   });
 
   test("language round-trips a code and the multi code-switching mode", () => {
@@ -107,6 +118,10 @@ describe("managed provider", () => {
       mode: "managed",
       provider: "vellum",
     });
-    expect(parsed).toEqual({ provider: "vellum", providers: {} });
+    expect(parsed).toEqual({
+      provider: "vellum",
+      language: "multi",
+      providers: {},
+    });
   });
 });

package/src/config/schemas/call-site-catalog.ts

@@ -289,11 +289,11 @@ const CATALOG_RECORD: CatalogRecord = {
       "Captions images via a vision-capable profile for text-only model fallback.",
     domain: "skills",
   },
-  voiceFrontDecision: {
-    id: "voiceFrontDecision",
-    displayName: "Voice Front Decision",
+  voiceProgressNarration: {
+    id: "voiceProgressNarration",
+    displayName: "Voice Progress Narration",
     description:
-      "Fast turn-taking and presence decisions during live voice (semantic endpointing, ack generation).",
+      "Phrases short spoken progress updates during long-running live voice turns.",
     domain: "agentLoop",
   },
   voiceFrontDoor: {

package/src/config/schemas/calls.ts

@@ -43,10 +43,6 @@ const CallsSafetyConfigSchema = z
 
 const CallsVoiceConfigSchema = z
   .object({
-    language: z
-      .string({ error: "calls.voice.language must be a string" })
-      .default("en-US")
-      .describe("BCP-47 language code for speech recognition and synthesis"),
     interruptSensitivity: z
       .enum(["low", "medium", "high"], {
         error:

package/src/config/schemas/channels.ts

@@ -68,6 +68,19 @@ export const TelegramConfigSchema = z
       .string({ error: "telegram.apiBaseUrl must be a string" })
       .default("https://api.telegram.org")
       .describe("Base URL for the Telegram Bot API"),
+    // Written by the gateway reconciler, read by the health sweep. Deployment
+    // state rather than user configuration: it records where this deployment
+    // last pointed Telegram, so the sweep can tell our own registration from a
+    // stale tunnel address or another deployment's callback. Unset until a
+    // reconciliation succeeds, which the sweep reports as unverified rather
+    // than healthy. Stripped by sanitize-for-transfer, like
+    // ingress.publicBaseUrlManagedBy, because it does not travel between hosts.
+    registeredWebhookUrl: z
+      .string({ error: "telegram.registeredWebhookUrl must be a string" })
+      .optional()
+      .describe(
+        "Webhook URL this deployment last registered with Telegram (managed by the gateway)",
+      ),
     deliverAuthBypass: z
       .boolean({ error: "telegram.deliverAuthBypass must be a boolean" })
       .default(false)

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

@@ -42,6 +42,31 @@ export const LiveVoiceVadConfigSchema = z
       .describe(
         "Sustained speech (ms) required before speech during assistant playback interrupts it — the default 'interrupt sensitivity' (higher = harder to interrupt). 0 disables the guard. Clients may override it per-session via the start frame. Raised from 60 so brief TTS bleed through imperfect echo cancellation no longer self-interrupts the assistant.",
       ),
+    echoBargeInMargin: z
+      .number({ error: "liveVoice.vad.echoBargeInMargin must be a number" })
+      .gt(1, "liveVoice.vad.echoBargeInMargin must be greater than 1")
+      .default(1.5)
+      .describe(
+        "Multiplier over the learned playback echo level that microphone input must exceed to count as speech during playback. Higher values reduce false interruptions but require louder barge-in speech.",
+      ),
+    echoEmaHalfLifeMs: z
+      .number({ error: "liveVoice.vad.echoEmaHalfLifeMs must be a number" })
+      .int("liveVoice.vad.echoEmaHalfLifeMs must be an integer")
+      .positive("liveVoice.vad.echoEmaHalfLifeMs must be a positive integer")
+      .default(400)
+      .describe(
+        "Half-life (ms) of the learned playback echo level. Smaller values adapt faster to changing speaker volume; larger values are steadier against transients.",
+      ),
+    echoDrainSlackMs: z
+      .number({ error: "liveVoice.vad.echoDrainSlackMs must be a number" })
+      .int("liveVoice.vad.echoDrainSlackMs must be an integer")
+      .nonnegative(
+        "liveVoice.vad.echoDrainSlackMs must be a nonnegative integer",
+      )
+      .default(300)
+      .describe(
+        "Time (ms) after the estimated client playback tail during which microphone input can still be classified as playback echo.",
+      ),
   })
   .describe(
     "Voice-activity-detection tuning for live voice sessions (open-mic turn segmentation)",
@@ -182,34 +207,64 @@ export const LiveVoiceFrontModelConfigSchema = z
       )
       .default(2)
       .describe("Cap on consecutive 'hold' extensions per utterance"),
-    ackFirstDeltaTimeoutMs: z
-      .number({
-        error: "liveVoice.frontModel.ackFirstDeltaTimeoutMs must be a number",
-      })
-      .int("liveVoice.frontModel.ackFirstDeltaTimeoutMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.ackFirstDeltaTimeoutMs must be a positive integer",
-      )
-      .default(2500)
-      .describe(
-        "Keyword-delay budget (ms): a spoken ack fires if no first assistant delta has arrived by then",
-      ),
-    ackGenerationTimeoutMs: z
-      .number({
-        error: "liveVoice.frontModel.ackGenerationTimeoutMs must be a number",
-      })
-      .int("liveVoice.frontModel.ackGenerationTimeoutMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.ackGenerationTimeoutMs must be a positive integer",
-      )
-      .default(600)
-      .describe("Budget (ms) for LLM-generated ack text"),
     progress: LiveVoiceProgressConfigSchema.default(
       LiveVoiceProgressConfigSchema.parse({}),
     ),
   })
   .describe(
-    "Front-model presence layer tuning for live voice sessions (semantic endpointing + spoken acks + progress narration)",
+    "Voice front-door endpointing and long-turn progress narration tuning",
+  );
+
+const LiveVoiceFluxTurnEndConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "liveVoice.flux.turnEnd.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Commit the live-voice turn on Flux's EndOfTurn instead of the front-door [0] hold verdict. Requires services.stt.provider to be deepgram-flux; ignored otherwise.",
+      ),
+  })
+  .describe(
+    "Which signal commits a live voice turn when Deepgram Flux is the STT provider",
+  );
+
+export const LiveVoiceFluxConfigSchema = z
+  .object({
+    turnEnd: LiveVoiceFluxTurnEndConfigSchema.default(
+      LiveVoiceFluxTurnEndConfigSchema.parse({}),
+    ),
+    model: z
+      .string({ error: "liveVoice.flux.model must be a string" })
+      .default("flux-general-en")
+      .describe("Deepgram Flux model requested when opening the STT stream"),
+    eotThreshold: z
+      .number({ error: "liveVoice.flux.eotThreshold must be a number" })
+      .min(0.5, "liveVoice.flux.eotThreshold must be >= 0.5")
+      .max(0.9, "liveVoice.flux.eotThreshold must be <= 0.9")
+      .default(0.7)
+      .describe(
+        "End-of-turn confidence Flux must reach before it emits EndOfTurn. Lower values commit sooner and cut speakers off more often; higher values wait longer and add end-of-turn latency.",
+      ),
+    eagerEotThreshold: z
+      .number({ error: "liveVoice.flux.eagerEotThreshold must be a number" })
+      .min(0.3, "liveVoice.flux.eagerEotThreshold must be >= 0.3")
+      .max(0.9, "liveVoice.flux.eagerEotThreshold must be <= 0.9")
+      .optional()
+      .describe(
+        "Confidence at which Flux starts speculating that the turn has ended. Leaving it unset disables Deepgram's EagerEndOfTurn / TurnResumed events; enabling it raises LLM calls 50-70% because speculative turns that resume are thrown away.",
+      ),
+    eotTimeoutMs: z
+      .number({ error: "liveVoice.flux.eotTimeoutMs must be a number" })
+      .int("liveVoice.flux.eotTimeoutMs must be an integer")
+      .min(500, "liveVoice.flux.eotTimeoutMs must be >= 500")
+      .max(60_000, "liveVoice.flux.eotTimeoutMs must be <= 60000")
+      .default(5_000)
+      .describe(
+        "Silence (ms) after which Flux force-ends the turn even though its end-of-turn confidence never reached eotThreshold",
+      ),
+  })
+  .describe(
+    "Deepgram Flux turn-detection tuning for live voice sessions (model-integrated end-of-turn)",
   );
 
 export const LiveVoiceConfigSchema = z
@@ -226,6 +281,9 @@ export const LiveVoiceConfigSchema = z
     frontModel: LiveVoiceFrontModelConfigSchema.default(
       LiveVoiceFrontModelConfigSchema.parse({}),
     ),
+    flux: LiveVoiceFluxConfigSchema.default(
+      LiveVoiceFluxConfigSchema.parse({}),
+    ),
     maxSessionDurationSeconds: z
       .number({
         error: "liveVoice.maxSessionDurationSeconds must be a number",
@@ -255,3 +313,4 @@ export type LiveVoiceFrontModelConfig = z.infer<
 export type LiveVoiceProgressConfig = z.infer<
   typeof LiveVoiceProgressConfigSchema
 >;
+export type LiveVoiceFluxConfig = z.infer<typeof LiveVoiceFluxConfigSchema>;

package/src/config/schemas/llm.ts

@@ -188,7 +188,7 @@ export const LLMCallSiteEnum = z.enum([
   "skillCategoryInference",
   "inference",
   "vision",
-  "voiceFrontDecision",
+  "voiceProgressNarration",
   "voiceFrontDoor",
   "trustRuleSuggestion",
   "homeGreeting",

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

@@ -2,6 +2,28 @@ import { z } from "zod";
 
 export const MemoryRetrospectiveConfigSchema = z
   .object({
+    // This kill switch exists only because conversation forking is expensive:
+    // a fork full-copies the source conversation (messages + attachments), so
+    // on a large conversation the retrospective's write burst can lock the
+    // SQLite table against other writers. Until forking is referential, an
+    // operator needs a way to stop retrospectives without turning off memory.
+    enabled: z
+      .boolean({ error: "memory.retrospective.enabled must be a boolean" })
+      .default(true)
+      .describe(
+        "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.",
+      ),
+
+    forkStrategy: z
+      .enum(["cloning", "reference"], {
+        error:
+          "memory.retrospective.forkStrategy must be 'cloning' or 'reference'",
+      })
+      .default("cloning")
+      .describe(
+        "How a retrospective's fork of the source conversation is materialized. `cloning` (default) full-copies the source conversation's messages and attachments into the fork. `reference` makes the fork referential: it holds only its own messages and reads the source's through `fork_parent_message_id`, so a fork costs a single row instead of a full copy of the conversation.",
+      ),
+
     timeThresholdMs: z
       .number({
         error: "memory.retrospective.timeThresholdMs must be a number",
@@ -108,3 +130,6 @@ export const MemoryRetrospectiveConfigSchema = z
 export type MemoryRetrospectiveConfig = z.infer<
   typeof MemoryRetrospectiveConfigSchema
 >;
+
+/** How a retrospective materializes its fork of the source conversation. */
+export type MemoryForkStrategy = MemoryRetrospectiveConfig["forkStrategy"];

package/src/config/schemas/plugin-updates.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+
+/**
+ * Unattended plugin upgrade configuration.
+ *
+ * The resource monitor process runs a periodic sweep (see
+ * `monitoring/plugin-auto-update.ts`) that moves every installed, enabled
+ * marketplace plugin to the catalog's current pin. The sweep is off by default:
+ * `mode: "manual"` means nothing upgrades unless a human runs
+ * `assistant plugins upgrade <name>` (or the equivalent route), which is the
+ * behavior every workspace had before this block existed. Setting
+ * `mode: "auto"` opts the workspace into the hourly sweep.
+ *
+ * Opting in never covers plugins installed straight from a GitHub URL. Those
+ * track a mutable ref rather than a reviewed pin, so the sweep leaves them to
+ * an explicit `assistant plugins upgrade`.
+ */
+export const PluginUpdatesConfigSchema = z
+  .object({
+    mode: z
+      .enum(["manual", "auto"], {
+        error: 'pluginUpdates.mode must be "manual" or "auto"',
+      })
+      .default("manual")
+      .describe(
+        'How installed plugins move to newer revisions. "manual" (default) never upgrades on its own: upgrades happen only when a human asks for one. "auto" lets the resource monitor upgrade every installed, enabled marketplace plugin on the `checkIntervalMs` cadence. Plugins installed directly from a GitHub URL are never upgraded automatically, since they track a mutable ref instead of a reviewed pin.',
+      ),
+    strategy: z
+      // Deliberately narrower than the full `PluginUpgradeStrategy` union: the
+      // `assistant` strategy resolves conflicts by writing git conflict
+      // markers into the plugin's files and expecting someone to resolve
+      // them. Unattended, that would leave a syntactically broken plugin on
+      // disk with nobody in the loop, so it is not selectable here. It stays
+      // available for interactive `assistant plugins upgrade --strategy
+      // assistant`.
+      .enum(["theirs", "ours", "overwrite"], {
+        error:
+          'pluginUpdates.strategy must be "theirs", "ours", or "overwrite"',
+      })
+      .default("theirs")
+      .describe(
+        'How an automatic upgrade reconciles local edits to a plugin with the incoming revision. "theirs" (default) three-way merges and resolves conflicting hunks toward the incoming revision, keeping non-conflicting local edits; "ours" merges the same way but resolves conflicts toward the local edit; "overwrite" discards local edits and re-installs the revision wholesale. Only consulted when `mode` is "auto".',
+      ),
+    checkIntervalMs: z
+      .number({ error: "pluginUpdates.checkIntervalMs must be a number" })
+      .int("pluginUpdates.checkIntervalMs must be an integer")
+      .min(300_000, "pluginUpdates.checkIntervalMs must be at least 300000ms")
+      .max(
+        604_800_000,
+        "pluginUpdates.checkIntervalMs must be <= 604800000ms (7 days)",
+      )
+      .default(3_600_000)
+      .describe(
+        'Minimum interval between automatic upgrade sweeps, in milliseconds (default 1 hour). The last sweep is stamped on disk, so restarting the daemon does not re-run a sweep that already ran within the interval. Only consulted when `mode` is "auto".',
+      ),
+  })
+  .describe("Unattended plugin upgrade configuration");
+
+export type PluginUpdatesConfig = z.infer<typeof PluginUpdatesConfigSchema>;

package/src/config/schemas/services.ts

@@ -139,10 +139,14 @@ export const ServicesSchema = z.object({
     WebSearchServiceSchema.parse({}),
   ),
   "web-fetch": WebFetchServiceSchema.default(WebFetchServiceSchema.parse({})),
-  stt: SttServiceSchema.default({
-    provider: "deepgram" as const,
-    providers: {},
-  }),
+  // Parsed rather than handed a literal, like every sibling here: a literal
+  // default short-circuits the inner parse, so field-level defaults inside
+  // the block (the multilingual `language`) would never materialize for a
+  // config that omits `services.stt` entirely, which is every fresh
+  // workspace.
+  stt: SttServiceSchema.default(
+    SttServiceSchema.parse({ provider: "deepgram", providers: {} }),
+  ),
   tts: TtsServiceSchema.default(TtsServiceSchema.parse({})),
   "google-oauth": GoogleOAuthServiceSchema.default(
     GoogleOAuthServiceSchema.parse({}),

package/src/config/schemas/stt.ts

@@ -6,6 +6,7 @@ import { z } from "zod";
  */
 export const VALID_STT_PROVIDERS = [
   "deepgram",
+  "deepgram-flux",
   "google-gemini",
   "openai-whisper",
   "xai",
@@ -67,22 +68,34 @@ export const SttServiceSchema = z
       .describe("Active STT provider used for speech-to-text transcription"),
     /**
      * Spoken-language selection, forwarded to providers whose adapters accept
-     * a language (Deepgram, xAI, and the managed relay). Left unset the
-     * provider applies its own default, which for Deepgram (and therefore
-     * for the managed relay) is English, NOT auto-detection.
+     * a language (Deepgram, xAI, and the managed relay).
      *
      * `"multi"` selects Deepgram's nova-3 code-switching mode, which follows
      * a speaker moving between languages inside a single utterance (e.g.
      * Hinglish). Providers that auto-detect natively and take no language
      * option (Gemini, Whisper) ignore this field.
+     *
+     * Defaults to `"multi"` rather than staying unset, so there is no state
+     * where the answer to "what language is this assistant listening for"
+     * has to be inferred. Every config carries the answer, and the settings
+     * surfaces render a real selection rather than a sentinel standing in
+     * for one.
+     *
+     * The default applies on load, not just at creation, so an existing
+     * config that never set a language materializes `"multi"` on its next
+     * start. That changes no behavior: `effectiveSttLanguage` already
+     * resolved unset to `"multi"` on Deepgram and the managed relay, and the
+     * providers that detect natively ignore the field either way. It only
+     * makes the value explicit. An assistant that has chosen a language
+     * keeps it, since a default fills nothing that is already set.
      */
     language: z
       .string({ error: "services.stt.language must be a string" })
       .trim()
       .min(1, { error: "services.stt.language must not be empty" })
-      .optional()
+      .default("multi")
       .describe(
-        "BCP-47 language code (e.g. 'en-US', 'hi') or 'multi' for code-switching across languages. Unset uses the provider default (English on Deepgram/managed, not auto-detect)",
+        "BCP-47 language code (e.g. 'en-US', 'hi') or 'multi' for code-switching across languages. Defaults to 'multi'; providers that detect natively ignore it",
       ),
     providers: SttProvidersSchema.default({}),
   })

package/src/config/schemas/timeouts.ts

@@ -26,7 +26,7 @@ export const TimeoutConfigSchema = z
       .positive("timeouts.permissionTimeoutSec must be a positive number")
       .default(300)
       .describe(
-        "How long to wait for user permission approval before timing out (seconds)",
+        "How long to wait for a human to approve a tool call before timing out (seconds). Spent by both approval paths: the interactive permission prompt, and the inline wait when a contact's sensitive tool call is escalated to the guardian.",
       ),
     questionResponseTimeoutSec: z
       .number({ error: "timeouts.questionResponseTimeoutSec must be a number" })