@vellumai/assistant 0.6.2 → 0.6.4

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

@@ -0,0 +1,112 @@
+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`
+ * (e.g. `chrome://inspect`-style remote debugging) as an alternative to the
+ * extension or local Playwright backend.
+ */
+export const HostBrowserCdpInspectConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "hostBrowser.cdpInspect.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Whether the cdp-inspect backend is enabled. When true, the factory will route browser tool calls through the configured host/port instead of the local Playwright backend.",
+      ),
+    host: z
+      .string({ error: "hostBrowser.cdpInspect.host must be a string" })
+      .transform((v) => v || "localhost")
+      .default("localhost")
+      .describe(
+        "Host name or IP address where the host Chrome instance exposes its remote debugging endpoint.",
+      ),
+    port: z
+      .number({ error: "hostBrowser.cdpInspect.port must be a number" })
+      .int("hostBrowser.cdpInspect.port must be an integer")
+      .min(1, "hostBrowser.cdpInspect.port must be >= 1")
+      .max(65535, "hostBrowser.cdpInspect.port must be <= 65535")
+      .default(9222)
+      .describe(
+        "TCP port for the host Chrome remote-debugging endpoint (matches `--remote-debugging-port`).",
+      ),
+    probeTimeoutMs: z
+      .number({
+        error: "hostBrowser.cdpInspect.probeTimeoutMs must be a number",
+      })
+      .int("hostBrowser.cdpInspect.probeTimeoutMs must be an integer")
+      .min(50, "hostBrowser.cdpInspect.probeTimeoutMs must be >= 50")
+      .max(5000, "hostBrowser.cdpInspect.probeTimeoutMs must be <= 5000")
+      .default(500)
+      .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.",
+  );
+
+export type HostBrowserCdpInspectConfig = z.infer<
+  typeof HostBrowserCdpInspectConfigSchema
+>;
+
+/**
+ * Top-level configuration for host-browser backends. Currently only exposes
+ * `cdpInspect`, but the shape leaves room for additional host-browser knobs
+ * (e.g. extension-specific settings) without another namespace churn.
+ */
+export const HostBrowserConfigSchema = z
+  .object({
+    cdpInspect: HostBrowserCdpInspectConfigSchema.default(
+      HostBrowserCdpInspectConfigSchema.parse({}),
+    ),
+  })
+  .describe("Host-browser backend configuration (cdp-inspect, etc.)");
+
+export type HostBrowserConfig = z.infer<typeof HostBrowserConfigSchema>;

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(7 * 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");

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

@@ -184,6 +184,106 @@ const MemoryFreshnessConfigSchema = z
     "Freshness-based ranking for memory retrieval — down-ranks old items unless recently reinforced",
   );
 
+const MemoryContextLoadInjectionSchema = z
+  .object({
+    maxNodes: z
+      .number({
+        error:
+          "memory.retrieval.injection.contextLoad.maxNodes must be a number",
+      })
+      .int("memory.retrieval.injection.contextLoad.maxNodes must be an integer")
+      .positive(
+        "memory.retrieval.injection.contextLoad.maxNodes must be a positive integer",
+      )
+      .default(25)
+      .describe("Maximum number of memory nodes to load at conversation start"),
+    serendipitySlots: z
+      .number({
+        error:
+          "memory.retrieval.injection.contextLoad.serendipitySlots must be a number",
+      })
+      .int(
+        "memory.retrieval.injection.contextLoad.serendipitySlots must be an integer",
+      )
+      .nonnegative(
+        "memory.retrieval.injection.contextLoad.serendipitySlots must be non-negative",
+      )
+      .default(5)
+      .describe("Number of random wildcard memory picks at conversation start"),
+    capabilityReserve: z
+      .number({
+        error:
+          "memory.retrieval.injection.contextLoad.capabilityReserve must be a number",
+      })
+      .int(
+        "memory.retrieval.injection.contextLoad.capabilityReserve must be an integer",
+      )
+      .nonnegative(
+        "memory.retrieval.injection.contextLoad.capabilityReserve must be non-negative",
+      )
+      .default(5)
+      .describe(
+        "Reserved slots for skill/CLI capability nodes at conversation start",
+      ),
+  })
+  .describe("Memory injection limits at conversation start");
+
+const MemoryPerTurnInjectionSchema = z
+  .object({
+    maxNodes: z
+      .number({
+        error: "memory.retrieval.injection.perTurn.maxNodes must be a number",
+      })
+      .int("memory.retrieval.injection.perTurn.maxNodes must be an integer")
+      .positive(
+        "memory.retrieval.injection.perTurn.maxNodes must be a positive integer",
+      )
+      .default(6)
+      .describe(
+        "Maximum total memory nodes injected per turn (general + capability + serendipity)",
+      ),
+    serendipitySlots: z
+      .number({
+        error:
+          "memory.retrieval.injection.perTurn.serendipitySlots must be a number",
+      })
+      .int(
+        "memory.retrieval.injection.perTurn.serendipitySlots must be an integer",
+      )
+      .nonnegative(
+        "memory.retrieval.injection.perTurn.serendipitySlots must be non-negative",
+      )
+      .default(1)
+      .describe("Number of random wildcard memory picks per turn"),
+    capabilityReserve: z
+      .number({
+        error:
+          "memory.retrieval.injection.perTurn.capabilityReserve must be a number",
+      })
+      .int(
+        "memory.retrieval.injection.perTurn.capabilityReserve must be an integer",
+      )
+      .nonnegative(
+        "memory.retrieval.injection.perTurn.capabilityReserve must be non-negative",
+      )
+      .default(2)
+      .describe("Reserved slots for skill/CLI capability nodes per turn"),
+  })
+  .describe("Memory injection limits for mid-conversation turns");
+
+export const MemoryInjectionConfigSchema = z
+  .object({
+    contextLoad: MemoryContextLoadInjectionSchema.default(
+      MemoryContextLoadInjectionSchema.parse({}),
+    ),
+    perTurn: MemoryPerTurnInjectionSchema.default(
+      MemoryPerTurnInjectionSchema.parse({}),
+    ),
+  })
+  .describe(
+    "Controls how many memory items are injected at conversation start and per turn",
+  );
+
 export const MemoryRetrievalConfigSchema = z
   .object({
     maxInjectTokens: z
@@ -209,6 +309,9 @@ export const MemoryRetrievalConfigSchema = z
     dynamicBudget: MemoryDynamicBudgetConfigSchema.default(
       MemoryDynamicBudgetConfigSchema.parse({}),
     ),
+    injection: MemoryInjectionConfigSchema.default(
+      MemoryInjectionConfigSchema.parse({}),
+    ),
   })
   .describe(
     "Controls how memories are retrieved and injected into conversations",

package/src/config/schemas/security.ts

@@ -79,12 +79,6 @@ export const PermissionsConfigSchema = z
       .describe(
         "Permission mode — 'strict' requires explicit approval for all operations, 'workspace' allows operations within the workspace",
       ),
-    askBeforeActing: z
-      .boolean({
-        error: "permissions.askBeforeActing must be a boolean",
-      })
-      .default(true)
-      .describe("Whether the assistant should check in before taking actions"),
     hostAccess: z
       .boolean({
         error: "permissions.hostAccess must be a boolean",

package/src/config/schemas/services.ts

@@ -1,5 +1,8 @@
 import { z } from "zod";
 
+import { SttServiceSchema } from "./stt.js";
+import { TtsServiceSchema } from "./tts.js";
+
 export const ServiceModeSchema = z.enum(["managed", "your-own"]);
 export type ServiceMode = z.infer<typeof ServiceModeSchema>;
 
@@ -61,6 +64,21 @@ export const LinearOAuthServiceSchema = BaseServiceSchema.extend({
 });
 export type LinearOAuthService = z.infer<typeof LinearOAuthServiceSchema>;
 
+export const GitHubOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type GitHubOAuthService = z.infer<typeof GitHubOAuthServiceSchema>;
+
+export const NotionOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type NotionOAuthService = z.infer<typeof NotionOAuthServiceSchema>;
+
+export const TwitterOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type TwitterOAuthService = z.infer<typeof TwitterOAuthServiceSchema>;
+
 export const ServicesSchema = z.object({
   inference: InferenceServiceSchema.default(InferenceServiceSchema.parse({})),
   "image-generation": ImageGenerationServiceSchema.default(
@@ -69,6 +87,12 @@ export const ServicesSchema = z.object({
   "web-search": WebSearchServiceSchema.default(
     WebSearchServiceSchema.parse({}),
   ),
+  stt: SttServiceSchema.default({
+    mode: "your-own" as const,
+    provider: "deepgram" as const,
+    providers: {},
+  }),
+  tts: TtsServiceSchema.default(TtsServiceSchema.parse({})),
   "google-oauth": GoogleOAuthServiceSchema.default(
     GoogleOAuthServiceSchema.parse({}),
   ),
@@ -78,5 +102,33 @@ export const ServicesSchema = z.object({
   "linear-oauth": LinearOAuthServiceSchema.default(
     LinearOAuthServiceSchema.parse({}),
   ),
+  "github-oauth": GitHubOAuthServiceSchema.default(
+    GitHubOAuthServiceSchema.parse({}),
+  ),
+  "notion-oauth": NotionOAuthServiceSchema.default(
+    NotionOAuthServiceSchema.parse({}),
+  ),
+  "twitter-oauth": TwitterOAuthServiceSchema.default(
+    TwitterOAuthServiceSchema.parse({}),
+  ),
 });
 export type Services = z.infer<typeof ServicesSchema>;
+
+/**
+ * Safely read the `mode` of a `services.*` entry.
+ *
+ * Most service entries (OAuth providers, inference, etc.) extend
+ * `BaseServiceSchema` and therefore carry a `mode: "managed" | "your-own"`
+ * field.
+ *
+ * Returns `undefined` when the requested service entry has no `mode` field,
+ * so callers can treat those entries as implicitly "your-own" without the
+ * compiler tripping on a union widened by non-BaseService members.
+ */
+export function getServiceMode(
+  services: Services,
+  key: keyof Services,
+): ServiceMode | undefined {
+  const entry = services[key] as { mode?: ServiceMode };
+  return entry.mode;
+}

package/src/config/schemas/stt.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+
+/**
+ * Valid STT provider identifiers. New providers append here and register
+ * an adapter.
+ */
+export const VALID_STT_PROVIDERS = [
+  "deepgram",
+  "google-gemini",
+  "openai-whisper",
+] as const;
+
+/**
+ * Sparse provider config map under `services.stt.providers`.
+ *
+ * This is a forward-compatible record that accepts any provider ID as key
+ * with an object value. All provider entries — known (`openai-whisper`,
+ * `deepgram`, `google-gemini`) and unknown — are accepted with generic object
+ * validation. Adding a new provider ID does not require a migration to seed
+ * `services.stt.providers.<id>`.
+ *
+ * The map only holds entries the user has explicitly configured — it is
+ * NOT required to enumerate every known provider.
+ */
+export const SttProvidersSchema = z.record(
+  z.string(),
+  z.record(z.string(), z.unknown()).default({}),
+);
+export type SttProviders = z.infer<typeof SttProvidersSchema>;
+
+/**
+ * Canonical STT service configuration.
+ *
+ * `mode` is locked to `"your-own"` -- managed STT is not supported.
+ * Attempting to set `mode: "managed"` will fail schema validation.
+ */
+export const SttServiceSchema = z
+  .object({
+    mode: z
+      .literal("your-own", {
+        error:
+          'services.stt.mode must be "your-own" -- managed STT is not supported',
+      })
+      .default("your-own" as const)
+      .describe(
+        'STT service mode -- only "your-own" is supported (managed STT is not available)',
+      ),
+    provider: z
+      .enum(VALID_STT_PROVIDERS, {
+        error: `services.stt.provider must be one of: ${VALID_STT_PROVIDERS.join(", ")}`,
+      })
+      .describe("Active STT provider used for speech-to-text transcription"),
+    providers: SttProvidersSchema.default({}),
+  })
+  .describe(
+    "Speech-to-text service configuration -- provider selection and per-provider settings",
+  );
+
+export type SttService = z.infer<typeof SttServiceSchema>;