@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/config/profile-materialization.ts

@@ -10,18 +10,18 @@ import type { LLMConfigBase, ProfileEntry } from "./schemas/llm.js";
 
 /**
  * Materializes a partial custom profile into a complete, standalone
- * override: what `resolveCallSiteConfig` produces when this profile is the
- * only profile layer above `llm.default`. Replicates the deep-merge
- * resolver's non-obvious rules exactly:
+ * override by filling absent fields from `dflt` (the workspace's default
+ * base config — the legacy raw `llm.default` blob when one is still on
+ * disk, otherwise `LLMConfigBase` schema defaults). Single-winner
+ * resolution never merges one profile's fields into another, so a custom
+ * profile must carry its own provider and model to be a usable selection
+ * target — materialization is what completes it. Rules:
  *
- * - Non-null default `temperature`/`topP` ARE inherited — winning-profile
- *   scoping only blocks one profile's sampling from leaking under another;
- *   `llm.default`'s base sampling stands when no profile opts in. Null
- *   defaults are skipped (same resolved result, no noise). `logitBias` is
- *   NEVER inherited — the resolver deletes non-profile values post-merge.
- * - A model-only profile gets the provider `withImpliedProviders` would
- *   stamp: the default provider when it serves the model, else the model's
- *   catalog owner.
+ * - Non-null base `temperature`/`topP` ARE inherited; null values are
+ *   skipped (same resolved result, no noise). `logitBias` is NEVER
+ *   inherited — it is profile-opt-in only.
+ * - A model-only profile gets the provider the catalog implies: the base
+ *   provider when it serves the model, else the model's catalog owner.
  *
  * Mix profiles (no config fields, schema-enforced) and managed profiles
  * (bodies owned by the code catalog) pass through untouched. Idempotent,

package/src/config/schema.ts

@@ -60,135 +60,101 @@ import { ToolsConfigSchema } from "./schemas/tools.js";
 import { WorkflowsConfigSchema } from "./schemas/workflows.js";
 import { WorkspaceGitConfigSchema } from "./schemas/workspace-git.js";
 
-export const AssistantConfigSchema = z
-  .object({
-    services: ServicesSchema.default(ServicesSchema.parse({})),
-    memory: MemoryConfigSchema.default(MemoryConfigSchema.parse({})),
-    monitoring: MonitoringConfigSchema.default(
-      MonitoringConfigSchema.parse({}),
+export const AssistantConfigSchema = z.object({
+  services: ServicesSchema.default(ServicesSchema.parse({})),
+  memory: MemoryConfigSchema.default(MemoryConfigSchema.parse({})),
+  monitoring: MonitoringConfigSchema.default(MonitoringConfigSchema.parse({})),
+  migrations: MigrationsConfigSchema.default(MigrationsConfigSchema.parse({})),
+  dataDir: z
+    .string({ error: "dataDir must be a string" })
+    .default(getDataDir())
+    .describe("Directory for storing assistant data (database, logs, etc.)"),
+  timeouts: TimeoutConfigSchema.default(TimeoutConfigSchema.parse({})),
+  rateLimit: RateLimitConfigSchema.default(RateLimitConfigSchema.parse({})),
+  secretDetection: SecretDetectionConfigSchema.default(
+    SecretDetectionConfigSchema.parse({}),
+  ),
+  auditLog: AuditLogConfigSchema.default(AuditLogConfigSchema.parse({})),
+  logFile: LogFileConfigSchema.default(
+    LogFileConfigSchema.parse({ dir: getDataDir() + "/logs" }),
+  ),
+  // Unified LLM configuration block. The unique source of truth for
+  // provider/model/maxTokens/effort/speed/temperature/thinking/contextWindow
+  // and pricing overrides for every call site in the assistant.
+  //
+  // Default values live on each leaf inside `LLMSchema` (see
+  // `schemas/llm.ts`), so `LLMSchema.parse({})` returns a fully-populated
+  // object. This matches the pattern used by sibling schemas above and
+  // ensures the loader's leaf-deletion recovery path can repair a partially
+  // invalid `llm` block without falling back to `cloneDefaultConfig()`.
+  llm: LLMSchema.default(LLMSchema.parse({})),
+  llmRequestLogs: LlmRequestLogsConfigSchema,
+  filing: FilingConfigSchema.default(FilingConfigSchema.parse({})),
+  heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
+  hostBrowser: HostBrowserConfigSchema.default(
+    HostBrowserConfigSchema.parse({}),
+  ),
+  conversations: ConversationsConfigSchema.default(
+    ConversationsConfigSchema.parse({}),
+  ),
+  journal: JournalConfigSchema.default(JournalConfigSchema.parse({})),
+  backup: BackupConfigSchema.default(BackupConfigSchema.parse({})),
+  mcp: McpConfigSchema.default(McpConfigSchema.parse({})),
+  acp: AcpConfigSchema.default(AcpConfigSchema.parse({})),
+  skills: SkillsConfigSchema.default(SkillsConfigSchema.parse({})),
+  workspaceGit: WorkspaceGitConfigSchema.default(
+    WorkspaceGitConfigSchema.parse({}),
+  ),
+  compaction: CompactionConfigSchema.default(CompactionConfigSchema.parse({})),
+  compactionLogs: CompactionLogsConfigSchema,
+  twilio: TwilioConfigSchema.default(TwilioConfigSchema.parse({})),
+  calls: CallsConfigSchema.default(CallsConfigSchema.parse({})),
+  liveVoice: LiveVoiceConfigSchema.default(LiveVoiceConfigSchema.parse({})),
+  whatsapp: WhatsAppConfigSchema.default(WhatsAppConfigSchema.parse({})),
+  telegram: TelegramConfigSchema.default(TelegramConfigSchema.parse({})),
+  slack: SlackConfigSchema.default(SlackConfigSchema.parse({})),
+  a2a: A2AConfigSchema.default(A2AConfigSchema.parse({})),
+  ingress: IngressConfigSchema,
+  platform: PlatformConfigSchema.default(PlatformConfigSchema.parse({})),
+  daemon: DaemonConfigSchema.default(DaemonConfigSchema.parse({})),
+  notifications: NotificationsConfigSchema.default(
+    NotificationsConfigSchema.parse({}),
+  ),
+  ui: UiConfigSchema.default(UiConfigSchema.parse({})),
+  tools: ToolsConfigSchema.default(ToolsConfigSchema.parse({})),
+  workflows: WorkflowsConfigSchema.default(WorkflowsConfigSchema.parse({})),
+  // Per-plugin config blocks keyed by plugin name. The schema is intentionally
+  // permissive — each plugin's manifest supplies its own validator which the
+  // plugin bootstrap (`external-plugins-bootstrap.ts`) runs against the raw
+  // block under `plugins.<name>` before handing the parsed result to the
+  // plugin's `init()`. Keeping this open here means adding a new plugin does
+  // not require a core-schema change, while invalid configs still surface
+  // through the plugin's own validator at bootstrap.
+  plugins: z
+    .record(z.string(), z.unknown())
+    .optional()
+    .describe(
+      "Per-plugin configuration keyed by plugin name. Validated downstream by each plugin's manifest.config validator at bootstrap.",
     ),
-    migrations: MigrationsConfigSchema.default(
-      MigrationsConfigSchema.parse({}),
+  legacyTelemetryOptOut: z
+    .boolean()
+    .optional()
+    .describe(
+      "Fail-closed telemetry marker: set for a workspace that had an explicit local usage-data opt-out before telemetry moved to platform share_analytics consent. While set, usage telemetry stays disabled regardless of platform consent.",
     ),
-    dataDir: z
-      .string({ error: "dataDir must be a string" })
-      .default(getDataDir())
-      .describe("Directory for storing assistant data (database, logs, etc.)"),
-    timeouts: TimeoutConfigSchema.default(TimeoutConfigSchema.parse({})),
-    rateLimit: RateLimitConfigSchema.default(RateLimitConfigSchema.parse({})),
-    secretDetection: SecretDetectionConfigSchema.default(
-      SecretDetectionConfigSchema.parse({}),
+  legacyDiagnosticsOptOut: z
+    .boolean()
+    .optional()
+    .describe(
+      "Fail-closed diagnostics marker: set for a workspace that had an explicit local sendDiagnostics opt-out before crash reporting moved to platform share_diagnostics consent. While set, Sentry stays disabled regardless of platform consent.",
     ),
-    auditLog: AuditLogConfigSchema.default(AuditLogConfigSchema.parse({})),
-    logFile: LogFileConfigSchema.default(
-      LogFileConfigSchema.parse({ dir: getDataDir() + "/logs" }),
-    ),
-    // Unified LLM configuration block. The unique source of truth for
-    // provider/model/maxTokens/effort/speed/temperature/thinking/contextWindow
-    // and pricing overrides for every call site in the assistant.
-    //
-    // Default values live on each leaf inside `LLMSchema` (see
-    // `schemas/llm.ts`), so `LLMSchema.parse({})` returns a fully-populated
-    // object. This matches the pattern used by sibling schemas above and
-    // ensures the loader's leaf-deletion recovery path can repair a partially
-    // invalid `llm` block without falling back to `cloneDefaultConfig()`.
-    llm: LLMSchema.default(LLMSchema.parse({})),
-    llmRequestLogs: LlmRequestLogsConfigSchema,
-    filing: FilingConfigSchema.default(FilingConfigSchema.parse({})),
-    heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
-    hostBrowser: HostBrowserConfigSchema.default(
-      HostBrowserConfigSchema.parse({}),
-    ),
-    conversations: ConversationsConfigSchema.default(
-      ConversationsConfigSchema.parse({}),
-    ),
-    journal: JournalConfigSchema.default(JournalConfigSchema.parse({})),
-    backup: BackupConfigSchema.default(BackupConfigSchema.parse({})),
-    mcp: McpConfigSchema.default(McpConfigSchema.parse({})),
-    acp: AcpConfigSchema.default(AcpConfigSchema.parse({})),
-    skills: SkillsConfigSchema.default(SkillsConfigSchema.parse({})),
-    workspaceGit: WorkspaceGitConfigSchema.default(
-      WorkspaceGitConfigSchema.parse({}),
-    ),
-    compaction: CompactionConfigSchema.default(
-      CompactionConfigSchema.parse({}),
-    ),
-    compactionLogs: CompactionLogsConfigSchema,
-    twilio: TwilioConfigSchema.default(TwilioConfigSchema.parse({})),
-    calls: CallsConfigSchema.default(CallsConfigSchema.parse({})),
-    liveVoice: LiveVoiceConfigSchema.default(LiveVoiceConfigSchema.parse({})),
-    whatsapp: WhatsAppConfigSchema.default(WhatsAppConfigSchema.parse({})),
-    telegram: TelegramConfigSchema.default(TelegramConfigSchema.parse({})),
-    slack: SlackConfigSchema.default(SlackConfigSchema.parse({})),
-    a2a: A2AConfigSchema.default(A2AConfigSchema.parse({})),
-    ingress: IngressConfigSchema,
-    platform: PlatformConfigSchema.default(PlatformConfigSchema.parse({})),
-    daemon: DaemonConfigSchema.default(DaemonConfigSchema.parse({})),
-    notifications: NotificationsConfigSchema.default(
-      NotificationsConfigSchema.parse({}),
-    ),
-    ui: UiConfigSchema.default(UiConfigSchema.parse({})),
-    tools: ToolsConfigSchema.default(ToolsConfigSchema.parse({})),
-    workflows: WorkflowsConfigSchema.default(WorkflowsConfigSchema.parse({})),
-    // Per-plugin config blocks keyed by plugin name. The schema is intentionally
-    // permissive — each plugin's manifest supplies its own validator which the
-    // plugin bootstrap (`external-plugins-bootstrap.ts`) runs against the raw
-    // block under `plugins.<name>` before handing the parsed result to the
-    // plugin's `init()`. Keeping this open here means adding a new plugin does
-    // not require a core-schema change, while invalid configs still surface
-    // through the plugin's own validator at bootstrap.
-    plugins: z
-      .record(z.string(), z.unknown())
-      .optional()
-      .describe(
-        "Per-plugin configuration keyed by plugin name. Validated downstream by each plugin's manifest.config validator at bootstrap.",
-      ),
-    legacyTelemetryOptOut: z
-      .boolean()
-      .optional()
-      .describe(
-        "Fail-closed telemetry marker: set for a workspace that had an explicit local usage-data opt-out before telemetry moved to platform share_analytics consent. While set, usage telemetry stays disabled regardless of platform consent.",
-      ),
-    legacyDiagnosticsOptOut: z
-      .boolean()
-      .optional()
-      .describe(
-        "Fail-closed diagnostics marker: set for a workspace that had an explicit local sendDiagnostics opt-out before crash reporting moved to platform share_diagnostics consent. While set, Sentry stays disabled regardless of platform consent.",
-      ),
-    maxStepsPerSession: z
-      .number({ error: "maxStepsPerSession must be a number" })
-      .int("maxStepsPerSession must be an integer")
-      .min(1, "maxStepsPerSession must be >= 1")
-      .max(200, "maxStepsPerSession must be <= 200")
-      .default(50)
-      .describe("Maximum number of computer-use steps per session"),
-  })
-  .superRefine((config, ctx) => {
-    const llmContextWindow = config.llm?.default?.contextWindow;
-    if (
-      llmContextWindow?.targetBudgetRatio != null &&
-      llmContextWindow?.compactThreshold != null &&
-      llmContextWindow.targetBudgetRatio >= llmContextWindow.compactThreshold
-    ) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["llm", "default", "contextWindow", "targetBudgetRatio"],
-        message:
-          "llm.default.contextWindow.targetBudgetRatio must be less than llm.default.contextWindow.compactThreshold",
-      });
-    }
-    if (
-      llmContextWindow?.targetBudgetRatio != null &&
-      llmContextWindow?.summaryBudgetRatio != null &&
-      llmContextWindow.targetBudgetRatio <= llmContextWindow.summaryBudgetRatio
-    ) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["llm", "default", "contextWindow", "targetBudgetRatio"],
-        message:
-          "llm.default.contextWindow.targetBudgetRatio must be greater than llm.default.contextWindow.summaryBudgetRatio",
-      });
-    }
-  });
+  maxStepsPerSession: z
+    .number({ error: "maxStepsPerSession must be a number" })
+    .int("maxStepsPerSession must be an integer")
+    .min(1, "maxStepsPerSession must be >= 1")
+    .max(200, "maxStepsPerSession must be <= 200")
+    .default(50)
+    .describe("Maximum number of computer-use steps per session"),
+});
 
 export type AssistantConfig = z.infer<typeof AssistantConfigSchema>;

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

@@ -11,9 +11,9 @@ describe("LiveVoiceVadConfigSchema", () => {
     const parsed = LiveVoiceVadConfigSchema.parse({});
     expect(parsed).toEqual({
       speechEnergyThreshold: 800,
-      silenceThresholdMs: 800,
+      silenceThresholdMs: 1200,
       maxTurnDurationMs: 30_000,
-      bargeInMinSpeechMs: 60,
+      bargeInMinSpeechMs: 250,
     });
   });
 
@@ -64,22 +64,40 @@ describe("LiveVoiceConfigSchema", () => {
       mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
-        silenceThresholdMs: 800,
+        silenceThresholdMs: 1200,
         maxTurnDurationMs: 30_000,
-        bargeInMinSpeechMs: 60,
+        bargeInMinSpeechMs: 250,
       },
       maxSessionDurationSeconds: 1800,
+      // Off by default: voice turns carry only their transcript, no audio
+      // artifacts on the conversation messages (JARVIS-1283).
+      archiveAudio: false,
     });
   });
 
+  test("archiveAudio can be enabled", () => {
+    expect(
+      LiveVoiceConfigSchema.parse({ archiveAudio: true }).archiveAudio,
+    ).toBe(true);
+  });
+
+  test("rejects a non-boolean archiveAudio", () => {
+    const result = LiveVoiceConfigSchema.safeParse({ archiveAudio: "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.archiveAudio"))).toBe(true);
+    }
+  });
+
   test("accepts overrides", () => {
     const parsed = LiveVoiceConfigSchema.parse({
       mode: "ptt",
-      vad: { silenceThresholdMs: 1200 },
+      vad: { silenceThresholdMs: 900 },
       maxSessionDurationSeconds: 600,
     });
     expect(parsed.mode).toBe("ptt");
-    expect(parsed.vad.silenceThresholdMs).toBe(1200);
+    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);

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

@@ -41,6 +41,31 @@ describe("SttServiceSchema", () => {
   test("VALID_STT_PROVIDERS includes deepgram", () => {
     expect(VALID_STT_PROVIDERS).toContain("deepgram");
   });
+
+  test("normalizes the openai/whisper aliases to openai-whisper", () => {
+    expect(SttServiceSchema.parse({ provider: "openai" }).provider).toBe(
+      "openai-whisper",
+    );
+    expect(SttServiceSchema.parse({ provider: "whisper" }).provider).toBe(
+      "openai-whisper",
+    );
+    // Case- and whitespace-tolerant.
+    expect(SttServiceSchema.parse({ provider: "  OpenAI  " }).provider).toBe(
+      "openai-whisper",
+    );
+  });
+
+  test("a canonical provider is unchanged by the alias preprocessor", () => {
+    expect(
+      SttServiceSchema.parse({ provider: "openai-whisper" }).provider,
+    ).toBe("openai-whisper");
+  });
+
+  test("rejects an unknown provider with a helpful message", () => {
+    expect(() => SttServiceSchema.parse({ provider: "nope" })).toThrow(
+      /must be one of/,
+    );
+  });
 });
 
 describe("managed mode", () => {
@@ -61,15 +86,18 @@ describe("managed mode", () => {
     expect(parsed.provider).toBe("vellum");
   });
 
-  test("rejects provider vellum under your-own mode", () => {
+  test("accepts provider vellum regardless of mode", () => {
     const result = SttServiceSchema.safeParse({
       mode: "your-own",
       provider: "vellum",
     });
-    expect(result.success).toBe(false);
+    expect(result.success).toBe(true);
   });
 
-  test("effectiveSttProvider routes managed mode to vellum and preserves BYOK otherwise", () => {
+  test("effectiveSttProvider routes provider vellum and managed mode to vellum, preserves BYOK otherwise", () => {
+    expect(effectiveSttProvider({ mode: "your-own", provider: "vellum" })).toBe(
+      "vellum",
+    );
     expect(
       effectiveSttProvider({ mode: "managed", provider: "deepgram" }),
     ).toBe("vellum");

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

@@ -20,9 +20,9 @@ export const LiveVoiceVadConfigSchema = z
       .number({ error: "liveVoice.vad.silenceThresholdMs must be a number" })
       .int("liveVoice.vad.silenceThresholdMs must be an integer")
       .positive("liveVoice.vad.silenceThresholdMs must be a positive integer")
-      .default(800)
+      .default(1200)
       .describe(
-        "Trailing silence duration (ms) after speech that ends the user's turn",
+        "Trailing silence duration (ms) after speech that ends the user's turn — the default 'pause before reply'. Clients may override it per-session via the start frame.",
       ),
     maxTurnDurationMs: z
       .number({ error: "liveVoice.vad.maxTurnDurationMs must be a number" })
@@ -38,9 +38,9 @@ export const LiveVoiceVadConfigSchema = z
       .nonnegative(
         "liveVoice.vad.bargeInMinSpeechMs must be a nonnegative integer",
       )
-      .default(60)
+      .default(250)
       .describe(
-        "Sustained speech (ms) required before speech during assistant playback interrupts it; 0 disables the guard",
+        "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.",
       ),
   })
   .describe(
@@ -68,6 +68,12 @@ export const LiveVoiceConfigSchema = z
       )
       .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)
+      .describe(
+        "Persist the recorded user + assistant audio of each voice turn as attachments on the conversation messages. Off by default: voice turns carry only their transcribed text, so no audio-file artifacts land in the conversation history. Enable for playback/debugging.",
+      ),
   })
   .describe(
     "Live voice (in-app duplex audio) configuration — mic mode, VAD tuning, and session limits",

package/src/config/schemas/llm.ts

@@ -31,6 +31,7 @@ export const LLMProvider = z
     "minimax",
     "atlascloud",
     "together",
+    "baseten",
   ])
   .meta({ id: "LLMProvider" });
 type LLMProvider = z.infer<typeof LLMProvider>;
@@ -261,14 +262,46 @@ export type ContextWindow = z.infer<typeof ContextWindowSchema>;
 // injected. Nested `overflowRecovery` likewise uses its fragment view, so a
 // partial override like `{ overflowRecovery: { maxAttempts: 5 } }` produces
 // exactly that and nothing else.
-const ContextWindowDeepPartialSchema = z.object({
-  enabled: ContextEnabledSchema.optional(),
-  maxInputTokens: ContextMaxInputTokensSchema.optional(),
-  targetBudgetRatio: ContextTargetBudgetRatioSchema.optional(),
-  compactThreshold: ContextCompactThresholdSchema.optional(),
-  summaryBudgetRatio: ContextSummaryBudgetRatioSchema.optional(),
-  overflowRecovery: ContextOverflowRecoveryFragmentSchema.optional(),
-});
+//
+// Cross-field ordering (targetBudgetRatio < compactThreshold, and
+// targetBudgetRatio > summaryBudgetRatio) is enforced only when both sides of
+// a pair are present in the same fragment — a partial override merges with
+// lower layers at resolution time, so a lone field can't be judged here.
+const ContextWindowDeepPartialSchema = z
+  .object({
+    enabled: ContextEnabledSchema.optional(),
+    maxInputTokens: ContextMaxInputTokensSchema.optional(),
+    targetBudgetRatio: ContextTargetBudgetRatioSchema.optional(),
+    compactThreshold: ContextCompactThresholdSchema.optional(),
+    summaryBudgetRatio: ContextSummaryBudgetRatioSchema.optional(),
+    overflowRecovery: ContextOverflowRecoveryFragmentSchema.optional(),
+  })
+  .superRefine((cw, ctx) => {
+    if (
+      cw.targetBudgetRatio != null &&
+      cw.compactThreshold != null &&
+      cw.targetBudgetRatio >= cw.compactThreshold
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["targetBudgetRatio"],
+        message:
+          "contextWindow.targetBudgetRatio must be less than contextWindow.compactThreshold",
+      });
+    }
+    if (
+      cw.targetBudgetRatio != null &&
+      cw.summaryBudgetRatio != null &&
+      cw.targetBudgetRatio <= cw.summaryBudgetRatio
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["targetBudgetRatio"],
+        message:
+          "contextWindow.targetBudgetRatio must be greater than contextWindow.summaryBudgetRatio",
+      });
+    }
+  });
 
 // ---------------------------------------------------------------------------
 // OpenRouter provider-routing preferences
@@ -318,10 +351,11 @@ const PricingOverrideSchema = z.object({
 // ---------------------------------------------------------------------------
 
 /**
- * Fully specified LLM config. Used for `llm.default` — every knob has a
- * schema-level default, so `LLMConfigBase.parse({})` returns a complete
- * fallback object. This is essential for the loader's leaf-deletion recovery
- * path; see the comment on `ThinkingSchema` above.
+ * Fully specified LLM config: every knob has a schema-level default, so
+ * `LLMConfigBase.parse({})` returns a complete object. The resolver uses it as
+ * the code-owned base every resolved call-site config composes over (see
+ * `CODE_DEFAULT_BASE` in `llm-resolver.ts`), and profile materialization
+ * completes partial custom profiles against it.
  */
 export const LLMConfigBase = z.object({
   provider: LLMProvider.default("anthropic"),
@@ -510,7 +544,6 @@ const DefaultProviderField = DefaultProviderSchema.optional().catch(undefined);
 
 export const LLMSchema = z
   .object({
-    default: LLMConfigBase.default(LLMConfigBase.parse({})),
     profiles: z.record(z.string().min(1), ProfileEntry).default({}),
     // Presentation-only order for named profiles. The resolver ignores this;
     // clients use it to render profile pickers consistently.
@@ -551,7 +584,9 @@ export const LLMSchema = z
       ...DEFAULT_PROFILE_KEYS,
     ]);
     for (const [siteId, siteConfig] of Object.entries(config.callSites ?? {})) {
-      if (siteConfig?.profile == null) continue;
+      if (siteConfig?.profile == null) {
+        continue;
+      }
       if (!profileNames.has(siteConfig.profile)) {
         ctx.addIssue({
           code: "custom",
@@ -596,7 +631,9 @@ export const LLMSchema = z
         .map(([name]) => name),
     );
     for (const [name, profile] of Object.entries(config.profiles ?? {})) {
-      if (profile?.mix == null) continue;
+      if (profile?.mix == null) {
+        continue;
+      }
       // (d) A mix must not also carry model config — the resolved config comes
       // entirely from the chosen constituent.
       for (const key of MIX_DISALLOWED_CONFIG_KEYS) {

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

@@ -137,7 +137,7 @@ export const MemoryCleanupConfigSchema = z
       .nullable()
       .default(1 * 60 * 60 * 1000)
       .describe(
-        "Retention period for LLM request/response logs in milliseconds (null keeps forever, 0 prunes immediately)",
+        "Retention period for LLM request/response logs in milliseconds (null or 0 disables pruning / keeps forever)",
       ),
   })
   .describe("Automatic memory cleanup and garbage collection settings");

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

@@ -57,6 +57,14 @@ export const MemoryRetrospectiveConfigSchema = z
       .describe(
         "When true, fork-based retrospectives run under the source conversation's inference profile (which forkConversation copies onto the fork) instead of the call site's default. Provider prompt caches are byte-exact prefix matches scoped per model, and a thinking enable/disable mismatch invalidates the messages cache tier — so reusing the source's cached prefix requires the retrospective to resolve the SAME model/thinking/effort as the conversation's own turns. Falls back to the call site's default when the conversation has no profile or the referenced profile no longer exists.",
       ),
+
+    promptPath: z
+      .string({ error: "memory.retrospective.promptPath must be a string" })
+      .nullable()
+      .default(null)
+      .describe(
+        "Optional path to a file whose contents replace the bundled retrospective fork-instruction prompt. Relative paths resolve under the workspace root; absolute paths and a leading `~/` (expanded to the home directory) are honored only when they still resolve inside the workspace root — a path that lands outside the workspace (including via symlinks) is rejected. The loaded contents may include `{{AVAILABLE_TOOLS_LINE}}`, `{{WINDOW_ANCHOR}}`, `{{ALREADY_REMEMBERED}}`, and `{{SKILL_AUTHORING_SECTION}}`, which are substituted at runtime. If the file is rejected, missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
+      ),
   })
   .describe(
     "Controls the memory-retrospective background pass. Model selection lives under llm.callSites.memoryRetrospective.",

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

@@ -235,7 +235,7 @@ export const MemoryV2ConfigSchema = z
       .nullable()
       .default(null)
       .describe(
-        "Optional path to a file whose contents replace the bundled consolidation prompt. Absolute paths are used as-is, a leading `~/` is expanded to the home directory, otherwise the path is resolved under the workspace root. The loaded contents may include `{{CUTOFF}}`, which is substituted with the run's ISO-8601 cutoff timestamp. If the file is missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
+        "Optional path to a file whose contents replace the bundled consolidation prompt. Relative paths resolve under the workspace root; absolute paths and a leading `~/` (expanded to the home directory) are honored only when they still resolve inside the workspace root — a path that lands outside the workspace (including via symlinks) is rejected. The loaded contents may include `{{CUTOFF}}`, which is substituted with the run's ISO-8601 cutoff timestamp. If the file is rejected, missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
       ),
     rerank: z
       .object({
@@ -306,7 +306,7 @@ export const MemoryV2ConfigSchema = z
           .nullable()
           .default(null)
           .describe(
-            "Optional path to a file whose contents replace the bundled router prompt. Absolute paths are used as-is, a leading `~/` is expanded to the home directory, otherwise the path is resolved under the workspace root. The loaded contents may include `{{ASSISTANT_NAME}}`, `{{USER_NAME}}`, and `{{PAGE_INDEX}}`, which are substituted at runtime. If the file is missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
+            "Optional path to a file whose contents replace the bundled router prompt. Relative paths resolve under the workspace root; absolute paths and a leading `~/` (expanded to the home directory) are honored only when they still resolve inside the workspace root — a path that lands outside the workspace (including via symlinks) is rejected. The loaded contents may include `{{ASSISTANT_NAME}}`, `{{USER_NAME}}`, and `{{PAGE_INDEX}}`, which are substituted at runtime. If the file is rejected, missing, unreadable, or empty, the bundled prompt is used and a warning is logged.",
           ),
         batch_size: z
           .number()

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

@@ -394,7 +394,7 @@ export const MemoryV3ConfigSchema = z
       .nullable()
       .default(null)
       .describe(
-        "Optional path to a file whose contents replace the bundled per-turn selector system prompt (the instructions that tell the selector which candidate pages to keep). Absolute paths are used as-is, a leading `~/` is expanded to the home directory, otherwise the path is resolved under the workspace root. The selector prompt takes no placeholders — the candidate pool is supplied separately as the user message — so the file is used verbatim. If the file is missing, unreadable, empty, or over 1 MiB, the bundled prompt is used and a warning is logged.",
+        "Optional path to a file whose contents replace the bundled per-turn selector system prompt (the instructions that tell the selector which candidate pages to keep). Relative paths resolve under the workspace root; absolute paths and a leading `~/` (expanded to the home directory) are honored only when they still resolve inside the workspace root — a path that lands outside the workspace (including via symlinks) is rejected. The selector prompt takes no placeholders — the candidate pool is supplied separately as the user message — so the file is used verbatim. If the file is rejected, missing, unreadable, empty, or over 1 MiB, the bundled prompt is used and a warning is logged.",
       ),
     edge: MemoryV3EdgeSchema.default(MemoryV3EdgeSchema.parse({})),
     entity: MemoryV3EntitySchema.default(MemoryV3EntitySchema.parse({})),

package/src/config/schemas/services.ts

@@ -66,12 +66,15 @@ const WebSearchServiceSchema = BaseServiceSchema.extend({
     .default("inference-provider-native"),
 });
 
-const WebFetchServiceSchema = BaseServiceSchema.extend({
+/**
+ * Web-fetch carries no `mode`: there is no managed proxy for it, so the only
+ * axis is which provider backs the tool.
+ */
+const WebFetchServiceSchema = z.object({
   // Provider that backs the `web_fetch` tool. `default` is the daemon's
   // built-in HTTP fetch + extract path (no key). BYOK providers (e.g.
   // `firecrawl`) scrape via their hosted API and reuse the same stored key as
-  // their web-search counterpart. The `mode` field is inherited from
-  // `BaseServiceSchema` for symmetry; web-fetch has no managed proxy today.
+  // their web-search counterpart.
   provider: z.enum(VALID_WEB_FETCH_PROVIDERS).default("default"),
 });