@vellumai/assistant 0.6.3 → 0.6.4

package/src/config/schema.ts

@@ -10,6 +10,10 @@ export {
 } from "../permissions/permission-mode.js";
 export type { AcpAgentConfig, AcpConfig } from "./acp-schema.js";
 export { AcpAgentConfigSchema, AcpConfigSchema } from "./acp-schema.js";
+export type { AnalysisConfig } from "./schemas/analysis.js";
+export { AnalysisConfigSchema } from "./schemas/analysis.js";
+export type { BackupConfig, BackupDestination } from "./schemas/backup.js";
+export { BackupConfigSchema } from "./schemas/backup.js";
 export type {
   CallerIdentityConfig,
   CallsConfig,
@@ -39,21 +43,19 @@ export {
   TwilioConfigSchema,
   WhatsAppConfigSchema,
 } from "./schemas/channels.js";
-export type { ElevenLabsConfig } from "./schemas/elevenlabs.js";
 export {
   DEFAULT_ELEVENLABS_VOICE_ID,
-  ElevenLabsConfigSchema,
   VALID_CONVERSATION_TIMEOUTS,
 } from "./schemas/elevenlabs.js";
-export type { FishAudioConfig } from "./schemas/fish-audio.js";
-export { FishAudioConfigSchema } from "./schemas/fish-audio.js";
 export type { HeartbeatConfig } from "./schemas/heartbeat.js";
 export { HeartbeatConfigSchema } from "./schemas/heartbeat.js";
 export type {
+  DesktopAutoCdpInspectConfig,
   HostBrowserCdpInspectConfig,
   HostBrowserConfig,
 } from "./schemas/host-browser.js";
 export {
+  DesktopAutoCdpInspectConfigSchema,
   HostBrowserCdpInspectConfigSchema,
   HostBrowserConfigSchema,
 } from "./schemas/host-browser.js";
@@ -192,16 +194,41 @@ export {
   SkillsInstallConfigSchema,
   SkillsLoadConfigSchema,
 } from "./schemas/skills.js";
+export type { SttProviders, SttService } from "./schemas/stt.js";
+export {
+  SttProvidersSchema,
+  SttServiceSchema,
+  VALID_STT_PROVIDERS,
+} from "./schemas/stt.js";
 export type { RateLimitConfig, TimeoutConfig } from "./schemas/timeouts.js";
 export {
   RateLimitConfigSchema,
   TimeoutConfigSchema,
 } from "./schemas/timeouts.js";
+export type {
+  TtsDeepgramProviderConfig,
+  TtsElevenLabsProviderConfig,
+  TtsFishAudioProviderConfig,
+  TtsProviders,
+  TtsService,
+} from "./schemas/tts.js";
+export {
+  TtsDeepgramProviderConfigSchema,
+  TtsElevenLabsProviderConfigSchema,
+  TtsFishAudioProviderConfigSchema,
+  TtsProvidersSchema,
+  TtsServiceSchema,
+  VALID_TTS_PROVIDERS as VALID_TTS_SERVICE_PROVIDERS,
+} from "./schemas/tts.js";
+export type { UpdatesConfig } from "./schemas/updates.js";
+export { UpdatesConfigSchema } from "./schemas/updates.js";
 export type { WorkspaceGitConfig } from "./schemas/workspace-git.js";
 export { WorkspaceGitConfigSchema } from "./schemas/workspace-git.js";
 
 // Imports for AssistantConfigSchema composition
 import { AcpConfigSchema } from "./acp-schema.js";
+import { AnalysisConfigSchema } from "./schemas/analysis.js";
+import { BackupConfigSchema } from "./schemas/backup.js";
 import { CallsConfigSchema } from "./schemas/calls.js";
 import {
   SlackConfigSchema,
@@ -209,9 +236,7 @@ import {
   TwilioConfigSchema,
   WhatsAppConfigSchema,
 } from "./schemas/channels.js";
-import { ElevenLabsConfigSchema } from "./schemas/elevenlabs.js";
 import { FilingConfigSchema } from "./schemas/filing.js";
-import { FishAudioConfigSchema } from "./schemas/fish-audio.js";
 import { HeartbeatConfigSchema } from "./schemas/heartbeat.js";
 import { HostBrowserConfigSchema } from "./schemas/host-browser.js";
 import {
@@ -245,6 +270,7 @@ import {
   RateLimitConfigSchema,
   TimeoutConfigSchema,
 } from "./schemas/timeouts.js";
+import { UpdatesConfigSchema } from "./schemas/updates.js";
 import { WorkspaceGitConfigSchema } from "./schemas/workspace-git.js";
 
 export const AssistantConfigSchema = z
@@ -287,10 +313,13 @@ export const AssistantConfigSchema = z
       ),
     filing: FilingConfigSchema.default(FilingConfigSchema.parse({})),
     heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
+    updates: UpdatesConfigSchema.default(UpdatesConfigSchema.parse({})),
     hostBrowser: HostBrowserConfigSchema.default(
       HostBrowserConfigSchema.parse({}),
     ),
     journal: JournalConfigSchema.default(JournalConfigSchema.parse({})),
+    analysis: AnalysisConfigSchema.default(AnalysisConfigSchema.parse({})),
+    backup: BackupConfigSchema.default(BackupConfigSchema.parse({})),
     mcp: McpConfigSchema.default(McpConfigSchema.parse({})),
     acp: AcpConfigSchema.default(AcpConfigSchema.parse({})),
     skills: SkillsConfigSchema.default(SkillsConfigSchema.parse({})),
@@ -299,10 +328,6 @@ export const AssistantConfigSchema = z
     ),
     twilio: TwilioConfigSchema.default(TwilioConfigSchema.parse({})),
     calls: CallsConfigSchema.default(CallsConfigSchema.parse({})),
-    elevenlabs: ElevenLabsConfigSchema.default(
-      ElevenLabsConfigSchema.parse({}),
-    ),
-    fishAudio: FishAudioConfigSchema.default(FishAudioConfigSchema.parse({})),
     whatsapp: WhatsAppConfigSchema.default(WhatsAppConfigSchema.parse({})),
     telegram: TelegramConfigSchema.default(TelegramConfigSchema.parse({})),
     slack: SlackConfigSchema.default(SlackConfigSchema.parse({})),

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

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  SttProvidersSchema,
+  SttServiceSchema,
+  VALID_STT_PROVIDERS,
+} from "../stt.js";
+
+describe("SttProvidersSchema", () => {
+  test("accepts a Deepgram entry with arbitrary fields (generic record)", () => {
+    const parsed = SttProvidersSchema.parse({
+      deepgram: { diarize: true },
+    });
+    expect(parsed).toEqual({ deepgram: { diarize: true } });
+  });
+
+  test("forward-compatible: unknown provider keys still pass validation", () => {
+    const parsed = SttProvidersSchema.parse({
+      "future-provider": { someField: 42 },
+    });
+    expect(parsed).toEqual({ "future-provider": { someField: 42 } });
+  });
+
+  test("empty providers map parses to {}", () => {
+    const parsed = SttProvidersSchema.parse({});
+    expect(parsed).toEqual({});
+  });
+});
+
+describe("SttServiceSchema", () => {
+  test("stt.provider=deepgram with providers.deepgram round-trips", () => {
+    const parsed = SttServiceSchema.parse({
+      provider: "deepgram",
+      providers: { deepgram: { diarize: true } },
+    });
+    expect(parsed.provider).toBe("deepgram");
+    expect(parsed.providers.deepgram).toEqual({ diarize: true });
+  });
+
+  test("VALID_STT_PROVIDERS includes deepgram", () => {
+    expect(VALID_STT_PROVIDERS).toContain("deepgram");
+  });
+});

package/src/config/schemas/analysis.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+
+export const AnalysisConfigSchema = z
+  .object({
+    // Number of new messages in the source conversation that trigger an
+    // analysis enqueue. Defaults to 3× the extraction batch size so analysis
+    // fires less often than extraction.
+    batchSize: z
+      .number({ error: "analysis.batchSize must be a number" })
+      .int("analysis.batchSize must be an integer")
+      .positive("analysis.batchSize must be a positive integer")
+      .default(30)
+      .describe(
+        "Number of new messages in the source conversation that trigger an analysis enqueue",
+      ),
+
+    // Idle window after the last message before the debounced analysis
+    // job fires. Defaults to 2× the extraction idle window.
+    idleTimeoutMs: z
+      .number({ error: "analysis.idleTimeoutMs must be a number" })
+      .int("analysis.idleTimeoutMs must be an integer")
+      .positive("analysis.idleTimeoutMs must be a positive integer")
+      .default(600_000)
+      .describe(
+        "Milliseconds of idle time after the last message before the debounced analysis job fires",
+      ),
+
+    // Optional model intent for the analysis agent loop. When omitted,
+    // the analysis agent uses the same model as the main agent.
+    // Accepted values match the main agent's model-intent vocabulary.
+    modelIntent: z
+      .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
+        error: "analysis.modelIntent must be a valid model intent",
+      })
+      .optional()
+      .describe(
+        "Model selection strategy for the analysis agent loop — falls back to the main agent's model when omitted",
+      ),
+
+    // Optional explicit model override (provider/model string). Takes
+    // precedence over modelIntent when both are set.
+    modelOverride: z
+      .string({ error: "analysis.modelOverride must be a string" })
+      .optional()
+      .describe(
+        "Explicit model override (provider/model string) for the analysis agent loop — takes precedence over modelIntent when both are set",
+      ),
+  })
+  .describe("Controls the auto-analyze agent loop triggered by conversation activity");
+
+export type AnalysisConfig = z.infer<typeof AnalysisConfigSchema>;

package/src/config/schemas/backup.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+
+export const BackupDestinationSchema = z
+  .object({
+    path: z
+      .string({ error: "backup.offsite.destinations[].path must be a string" })
+      .describe("Absolute path to the offsite destination directory"),
+    encrypt: z
+      .boolean({
+        error: "backup.offsite.destinations[].encrypt must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Encrypt backups written to this destination. Defaults to true; set to false only for destinations where the user trusts physical control (e.g. an external SSD).",
+      ),
+  })
+  .describe("A single offsite backup destination");
+
+export type BackupDestination = z.infer<typeof BackupDestinationSchema>;
+
+export const BackupOffsiteConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "backup.offsite.enabled must be a boolean" })
+      .default(true)
+      .describe("Whether offsite backup is enabled"),
+    destinations: z
+      .array(BackupDestinationSchema)
+      .nullable()
+      .default(null)
+      .describe(
+        "Offsite destinations. null means use the default iCloud Drive destination with encryption on; an explicit array (including []) overrides the default.",
+      ),
+  })
+  .describe("Offsite backup configuration");
+
+export type BackupOffsiteConfig = z.infer<typeof BackupOffsiteConfigSchema>;
+
+export const BackupConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "backup.enabled must be a boolean" })
+      .default(false)
+      .describe("Whether automated backups are enabled"),
+    intervalHours: z
+      .number({ error: "backup.intervalHours must be a number" })
+      .int("backup.intervalHours must be an integer")
+      .min(1, "backup.intervalHours must be >= 1")
+      .max(168, "backup.intervalHours must be <= 168")
+      .default(6)
+      .describe("Interval between automated backups, in hours"),
+    retention: z
+      .number({ error: "backup.retention must be a number" })
+      .int("backup.retention must be an integer")
+      .min(1, "backup.retention must be >= 1")
+      .max(100, "backup.retention must be <= 100")
+      .default(7)
+      .describe("Number of recent backups to retain"),
+    offsite: BackupOffsiteConfigSchema.default(
+      BackupOffsiteConfigSchema.parse({}),
+    ),
+    localDirectory: z
+      .string({ error: "backup.localDirectory must be a string" })
+      .nullable()
+      .default(null)
+      .describe(
+        "Directory for local backup snapshots. null means use the default workspace-adjacent location.",
+      ),
+  })
+  .describe("Automated backup configuration");
+
+export type BackupConfig = z.infer<typeof BackupConfigSchema>;

package/src/config/schemas/calls.ts

@@ -5,9 +5,6 @@ export const VALID_CALLER_IDENTITY_MODES = [
   "assistant_number",
   "user_number",
 ] as const;
-const VALID_CALL_TRANSCRIPTION_PROVIDERS = ["Deepgram", "Google"] as const;
-export const VALID_TTS_PROVIDERS = ["elevenlabs", "fish-audio"] as const;
-
 export const CallsDisclosureConfigSchema = z
   .object({
     enabled: z
@@ -50,30 +47,8 @@ export const CallsVoiceConfigSchema = z
       .string({ error: "calls.voice.language must be a string" })
       .default("en-US")
       .describe("BCP-47 language code for speech recognition and synthesis"),
-    transcriptionProvider: z
-      .enum(VALID_CALL_TRANSCRIPTION_PROVIDERS, {
-        error: `calls.voice.transcriptionProvider must be one of: ${VALID_CALL_TRANSCRIPTION_PROVIDERS.join(
-          ", ",
-        )}`,
-      })
-      .default("Deepgram")
-      .describe("Speech-to-text provider used for call transcription"),
-    speechModel: z
-      .string({ error: "calls.voice.speechModel must be a string" })
-      .optional()
-      .describe(
-        "ASR model to use for speech recognition (e.g. nova-3, nova-2-phonecall for Deepgram; telephony, long for Google)",
-      ),
-    ttsProvider: z
-      .enum(VALID_TTS_PROVIDERS, {
-        error: `calls.voice.ttsProvider must be one of: ${VALID_TTS_PROVIDERS.join(", ")}`,
-      })
-      .default("elevenlabs")
-      .describe("Text-to-speech provider for phone calls"),
     hints: z
-      .array(
-        z.string({ error: "calls.voice.hints values must be strings" }),
-      )
+      .array(z.string({ error: "calls.voice.hints values must be strings" }))
       .default([])
       .describe(
         "Static vocabulary hints for speech recognition — proper nouns, domain terms, and other words the STT provider should prioritize",

package/src/config/schemas/elevenlabs.ts

@@ -1,5 +1,3 @@
-import { z } from "zod";
-
 // Default ElevenLabs voice — "Amelia" (expressive, enthusiastic, British English).
 // Used by both in-app TTS and phone calls (via Twilio ConversationRelay).
 // Mirrored in: clients/macos/.../OpenAIVoiceService.swift (defaultVoiceId)
@@ -7,60 +5,3 @@ export const DEFAULT_ELEVENLABS_VOICE_ID = "ZF6FPAbjXT4488VcRRnw";
 
 /** Valid conversation timeout values (seconds). Shared with voice-config-update tool. */
 export const VALID_CONVERSATION_TIMEOUTS = [5, 10, 15, 30, 60] as const;
-
-export const ElevenLabsConfigSchema = z
-  .object({
-    voiceId: z
-      .string({ error: "elevenlabs.voiceId must be a string" })
-      .min(1, "elevenlabs.voiceId must not be empty")
-      .default(DEFAULT_ELEVENLABS_VOICE_ID)
-      .describe("ElevenLabs voice ID for text-to-speech"),
-    voiceModelId: z
-      .string({ error: "elevenlabs.voiceModelId must be a string" })
-      .default("")
-      .describe(
-        "ElevenLabs model ID override (leave empty to use the default model)",
-      ),
-    speed: z
-      .number({ error: "elevenlabs.speed must be a number" })
-      .min(0.7, "elevenlabs.speed must be >= 0.7")
-      .max(1.2, "elevenlabs.speed must be <= 1.2")
-      .default(1.0)
-      .describe(
-        "Speech playback speed multiplier (0.7 = slower, 1.2 = faster)",
-      ),
-    stability: z
-      .number({ error: "elevenlabs.stability must be a number" })
-      .min(0, "elevenlabs.stability must be >= 0")
-      .max(1, "elevenlabs.stability must be <= 1")
-      .default(0.5)
-      .describe(
-        "Voice stability — higher values produce more consistent speech, lower values add expressiveness",
-      ),
-    similarityBoost: z
-      .number({ error: "elevenlabs.similarityBoost must be a number" })
-      .min(0, "elevenlabs.similarityBoost must be >= 0")
-      .max(1, "elevenlabs.similarityBoost must be <= 1")
-      .default(0.75)
-      .describe(
-        "How closely the output matches the original voice — higher values increase similarity",
-      ),
-    conversationTimeoutSeconds: z
-      .number({
-        error: "elevenlabs.conversationTimeoutSeconds must be a number",
-      })
-      .refine(
-        (v) =>
-          VALID_CONVERSATION_TIMEOUTS.includes(
-            v as (typeof VALID_CONVERSATION_TIMEOUTS)[number],
-          ),
-        {
-          message: `elevenlabs.conversationTimeoutSeconds must be one of: ${VALID_CONVERSATION_TIMEOUTS.join(", ")}`,
-        },
-      )
-      .default(30)
-      .describe("Seconds of silence before voice conversation auto-ends"),
-  })
-  .describe("ElevenLabs text-to-speech configuration");
-
-export type ElevenLabsConfig = z.infer<typeof ElevenLabsConfigSchema>;

package/src/config/schemas/filing.ts

@@ -24,26 +24,66 @@ export const FilingConfigSchema = z
       .int("filing.activeHoursStart must be an integer")
       .min(0, "filing.activeHoursStart must be >= 0")
       .max(23, "filing.activeHoursStart must be <= 23")
-      .default(8)
-      .describe("Hour of the day (0-23) when filing runs begin"),
+      .nullable()
+      .default(null)
+      .describe(
+        "Hour of the day (0-23) when filing runs begin, or null to disable active hours restriction",
+      ),
     activeHoursEnd: z
       .number({ error: "filing.activeHoursEnd must be a number" })
       .int("filing.activeHoursEnd must be an integer")
       .min(0, "filing.activeHoursEnd must be >= 0")
       .max(23, "filing.activeHoursEnd must be <= 23")
-      .default(22)
-      .describe("Hour of the day (0-23) when filing runs stop"),
+      .nullable()
+      .default(null)
+      .describe(
+        "Hour of the day (0-23) when filing runs stop, or null to disable active hours restriction",
+      ),
   })
   .describe(
     "Periodic PKB (personal knowledge base) filing — processes the buffer into topic files and maintains knowledge organization",
   )
   .superRefine((config, ctx) => {
-    if (config.activeHoursStart === config.activeHoursEnd) {
+    const startNull = config.activeHoursStart == null;
+    const endNull = config.activeHoursEnd == null;
+    if (startNull !== endNull) {
+      // Emit on both fields so validateWithSchema's delete-and-retry repair
+      // can strip whichever side was set (and no-op the null side), letting
+      // the config fall back to both-null defaults without a full reset.
+      const message =
+        "filing.activeHoursStart and filing.activeHoursEnd must both be set or both be null";
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["activeHoursStart"],
+        message,
+      });
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["activeHoursEnd"],
+        message,
+      });
+      return;
+    }
+    if (
+      config.activeHoursStart != null &&
+      config.activeHoursEnd != null &&
+      config.activeHoursStart === config.activeHoursEnd
+    ) {
+      // Emit on both fields. Filing's defaults are null/null, so single-emit
+      // on one side would cascade: delete-and-retry strips one key, the null
+      // default recreates a new mismatch, and the loader falls back to full
+      // defaults — wiping unrelated fields like maxTokens.
+      const message =
+        "filing.activeHoursStart and filing.activeHoursEnd must not be equal (would create an empty window)";
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["activeHoursStart"],
+        message,
+      });
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
         path: ["activeHoursEnd"],
-        message:
-          "filing.activeHoursStart and filing.activeHoursEnd must not be equal (would create an empty window)",
+        message,
       });
     }
   });

package/src/config/schemas/heartbeat.ts

@@ -43,11 +43,23 @@ export const HeartbeatConfigSchema = z
     const startNull = config.activeHoursStart == null;
     const endNull = config.activeHoursEnd == null;
     if (startNull !== endNull) {
+      // Emit on both fields so validateWithSchema's delete-and-retry strips
+      // both sides in one pass. Single-emit on the null side can cascade when
+      // the explicit value happens to equal the opposite default (e.g.
+      // { start: null, end: 8 } → strip start → default 8 → equal check fires
+      // → loader falls back to full defaults, wiping unrelated keys like
+      // maxTokens).
+      const message =
+        "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must both be set or both be null";
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
-        path: [startNull ? "activeHoursStart" : "activeHoursEnd"],
-        message:
-          "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must both be set or both be null",
+        path: ["activeHoursStart"],
+        message,
+      });
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["activeHoursEnd"],
+        message,
       });
       return;
     }
@@ -56,11 +68,21 @@ export const HeartbeatConfigSchema = z
       config.activeHoursEnd != null &&
       config.activeHoursStart === config.activeHoursEnd
     ) {
+      // Emit on both fields. Single-emit would strip one side and the default
+      // for that side could recreate a new mismatch (e.g. { start: 22, end: 22 }
+      // → strip end → default 22 → equal again), cascading to a full defaults
+      // reset that wipes unrelated fields.
+      const message =
+        "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must not be equal (would create an empty window)";
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["activeHoursStart"],
+        message,
+      });
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
         path: ["activeHoursEnd"],
-        message:
-          "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must not be equal (would create an empty window)",
+        message,
       });
     }
   });

package/src/config/schemas/host-browser.ts

@@ -1,5 +1,48 @@
 import { z } from "zod";
 
+/**
+ * Configuration for the automatic cdp-inspect attempt on macOS. When a macOS
+ * turn reaches the CDP factory and `desktopAuto.enabled` is true, the factory
+ * includes cdp-inspect as a candidate even when the top-level `enabled` flag
+ * is false. This lets macOS users benefit from direct Chrome attach without
+ * requiring manual `hostBrowser.cdpInspect.enabled = true`.
+ *
+ * If the cdp-inspect probe fails (e.g. Chrome was not launched with
+ * `--remote-debugging-port`), the factory records a cooldown timestamp and
+ * skips the probe for subsequent calls until the cooldown expires. This bounds
+ * the per-call latency penalty to `probeTimeoutMs` once per cooldown window.
+ */
+export const DesktopAutoCdpInspectConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({
+        error: "hostBrowser.cdpInspect.desktopAuto.enabled must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Whether macOS turns automatically attempt cdp-inspect before falling back to the local Playwright backend. When true (default on macOS), the factory inserts a cdp-inspect candidate between the extension and local backends even when the top-level `cdpInspect.enabled` is false.",
+      ),
+    cooldownMs: z
+      .number({
+        error: "hostBrowser.cdpInspect.desktopAuto.cooldownMs must be a number",
+      })
+      .int("hostBrowser.cdpInspect.desktopAuto.cooldownMs must be an integer")
+      .min(0, "hostBrowser.cdpInspect.desktopAuto.cooldownMs must be >= 0")
+      .max(
+        300_000,
+        "hostBrowser.cdpInspect.desktopAuto.cooldownMs must be <= 300000",
+      )
+      .default(30_000)
+      .describe(
+        "Duration (in milliseconds) to suppress automatic cdp-inspect probes after a transport-level failure. While on cooldown the factory skips the cdp-inspect candidate and goes straight to the local backend. Set to 0 to disable cooldown (always probe).",
+      ),
+  })
+  .describe("Auto-attempt policy for cdp-inspect on macOS-originated turns.");
+
+export type DesktopAutoCdpInspectConfig = z.infer<
+  typeof DesktopAutoCdpInspectConfigSchema
+>;
+
 /**
  * Configuration for the `cdp-inspect` browser backend — connects directly
  * to a host Chrome instance that was launched with `--remote-debugging-port`
@@ -16,7 +59,7 @@ export const HostBrowserCdpInspectConfigSchema = z
       ),
     host: z
       .string({ error: "hostBrowser.cdpInspect.host must be a string" })
-      .min(1, "hostBrowser.cdpInspect.host must not be empty")
+      .transform((v) => v || "localhost")
       .default("localhost")
       .describe(
         "Host name or IP address where the host Chrome instance exposes its remote debugging endpoint.",
@@ -41,6 +84,9 @@ export const HostBrowserCdpInspectConfigSchema = z
       .describe(
         "Timeout (in milliseconds) for the backend availability probe. Kept small so browser tool calls fail fast when the endpoint is unreachable.",
       ),
+    desktopAuto: DesktopAutoCdpInspectConfigSchema.default(
+      DesktopAutoCdpInspectConfigSchema.parse({}),
+    ),
   })
   .describe(
     "Settings for the cdp-inspect backend that connects to a host Chrome instance via its remote-debugging endpoint.",

package/src/config/schemas/inference.ts

@@ -42,7 +42,7 @@ export const SpeedSchema = z
   })
   .default("standard")
   .describe(
-    'Inference speed mode — "fast" enables higher output token throughput on supported models (Opus 4.6) at premium pricing',
+    'Inference speed mode — "fast" enables higher output token throughput on supported models (Opus 4.6, Opus 4.7) at premium pricing',
   );
 
 export type Speed = z.infer<typeof SpeedSchema>;

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

@@ -80,9 +80,21 @@ export const MemoryCleanupConfigSchema = z
       .nonnegative(
         "memory.cleanup.llmRequestLogRetentionMs must be non-negative",
       )
-      .default(1 * 24 * 60 * 60 * 1000)
+      // Upper bound must match gateway MAX_LLM_REQUEST_LOG_RETENTION_MS in
+      // gateway/src/http/routes/privacy-config.ts. If a manually edited
+      // config.json sets a value larger than this, the gateway GET would
+      // return it and the macOS picker would snap it to its largest known
+      // option, and the next PATCH would silently truncate the value —
+      // causing quiet data loss. Enforcing the same cap here prevents the
+      // daemon from accepting out-of-range values in the first place.
+      .max(
+        365 * 24 * 60 * 60 * 1000,
+        "memory.cleanup.llmRequestLogRetentionMs must be <= 365 days in ms",
+      )
+      .nullable()
+      .default(1 * 60 * 60 * 1000)
       .describe(
-        "Retention period for LLM request/response logs in milliseconds (0 disables pruning)",
+        "Retention period for LLM request/response logs in milliseconds (null keeps forever, 0 prunes immediately)",
       ),
   })
   .describe("Automatic memory cleanup and garbage collection settings");