@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/compaction-events.test.ts

@@ -12,7 +12,7 @@ import { describe, expect, mock, test } from "bun:test";
 
 import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type { AgentEvent } from "../agent/loop.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AssistantEvent } from "../api/index.js";
 import type { ContextWindowResult } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
@@ -233,7 +233,7 @@ function makeProvider() {
 }
 
 function makeConversation(
-  collected: ServerMessage[],
+  collected: AssistantEvent[],
   id = "conv-compact-events",
 ): Conversation {
   return new Conversation(
@@ -254,7 +254,7 @@ function makeConversation(
 
 describe("forceCompact event emission", () => {
   test("emits context_compacted and a usage_update without contextWindow when compacted", async () => {
-    const collected: ServerMessage[] = [];
+    const collected: AssistantEvent[] = [];
     mockCompactResult = {
       messages: [],
       compacted: true,
@@ -279,7 +279,7 @@ describe("forceCompact event emission", () => {
     );
     expect(compactedEvents.length).toBe(1);
     const compactedEvent = compactedEvents[0] as Extract<
-      ServerMessage,
+      AssistantEvent,
       { type: "context_compacted" }
     >;
     expect(compactedEvent.conversationId).toBe("conv-compact-events");
@@ -298,7 +298,7 @@ describe("forceCompact event emission", () => {
     const usageEvents = collected.filter((m) => m.type === "usage_update");
     expect(usageEvents.length).toBe(1);
     const usageEvent = usageEvents[0] as Extract<
-      ServerMessage,
+      AssistantEvent,
       { type: "usage_update" }
     >;
     // `context_compacted` is now the single source of truth for the UI
@@ -312,7 +312,7 @@ describe("forceCompact event emission", () => {
   });
 
   test("emits context_compacted even when summary LLM was skipped (truncation-only path)", async () => {
-    const collected: ServerMessage[] = [];
+    const collected: AssistantEvent[] = [];
     mockCompactResult = {
       messages: [],
       compacted: true,
@@ -342,7 +342,7 @@ describe("forceCompact event emission", () => {
     );
     expect(compactedEvents.length).toBe(1);
     const compactedEvent = compactedEvents[0] as Extract<
-      ServerMessage,
+      AssistantEvent,
       { type: "context_compacted" }
     >;
     expect(compactedEvent.conversationId).toBe("conv-compact-trunc");
@@ -356,7 +356,7 @@ describe("forceCompact event emission", () => {
   });
 
   test("skips emission when compacted is false", async () => {
-    const collected: ServerMessage[] = [];
+    const collected: AssistantEvent[] = [];
     mockCompactResult = {
       messages: [],
       compacted: false,

package/src/__tests__/config-loader-platform-defaults.test.ts

@@ -76,9 +76,10 @@ function readConfig(): Record<string, unknown> {
 // Without IS_PLATFORM, services split by Zod schema default: google/notion-oauth
 // resolve to "managed" (per JARVIS-966), the rest resolve to "your-own".
 // web-search is deliberately absent: `provider` is its only axis, so the
-// platform context injects no mode for it.
+// platform context injects no mode for it. image-generation is also absent:
+// its managed axis is the provider ("vellum" proxies through the platform),
+// so the platform context fills `provider: "vellum"` rather than a mode.
 const MANAGED_SERVICES = [
-  "image-generation",
   "google-oauth",
   "outlook-oauth",
   "linear-oauth",
@@ -101,8 +102,9 @@ const SCHEMA_MANAGED_DEFAULT_SERVICES = [
 ] as const;
 
 // web-search is absent from both lists: it carries no mode at all.
+// image-generation and web-search are absent from both lists: they carry
+// no mode at all.
 const SCHEMA_YOUR_OWN_DEFAULT_SERVICES = [
-  "image-generation",
   "outlook-oauth",
   "linear-oauth",
   "github-oauth",
@@ -132,7 +134,7 @@ describe("platform-managed config defaults", () => {
     }
   });
 
-  test("IS_PLATFORM=true, no config file → all 7 managed service modes written as 'managed'", () => {
+  test("IS_PLATFORM=true, no config file → all 6 managed service modes written as 'managed', image-generation provider written as 'vellum'", () => {
     process.env.IS_PLATFORM = "true";
 
     loadConfig();
@@ -147,6 +149,15 @@ describe("platform-managed config defaults", () => {
     expect((services["web-search"] as { provider?: string })?.provider).toBe(
       "inference-provider-native",
     );
+    // image-generation's managed axis is its provider: the platform context
+    // fills "vellum" and never injects a managed mode (the persisted mode is
+    // the schema default).
+    const imageGen = services["image-generation"] as {
+      provider?: string;
+      mode?: string;
+    };
+    expect(imageGen?.provider).toBe("vellum");
+    expect(imageGen?.mode).not.toBe("managed");
   });
 
   test("IS_PLATFORM=false, no config file → service modes follow schema defaults (your-own except google/notion-oauth which are managed)", () => {
@@ -204,13 +215,16 @@ describe("platform-managed config defaults", () => {
 
     const written = readConfig() as { services?: Record<string, unknown> };
     expect(written.services).toBeDefined();
-    // The existing value must be preserved — backfill path, not fresh-write path
+    // The raw value must be preserved — backfill path, not fresh-write path.
+    // (Migration 134 rewrites this legacy shape at daemon startup; the loader
+    // itself must simply leave it alone.)
     expect(
       (written.services!["image-generation"] as { mode?: string })?.mode,
     ).toBe("your-own");
-    // ...and the in-memory config must mirror the explicit user choice (the
-    // fill-defaults pass must not override an explicit "your-own").
-    expect(config.services["image-generation"].mode).toBe("your-own");
+    // The parsed config strips the legacy key and carries the filled
+    // provider; no mode survives the schema.
+    expect(config.services["image-generation"]).not.toHaveProperty("mode");
+    expect(config.services["image-generation"].provider).toBe("vellum");
   });
 
   test("IS_PLATFORM=true, config file with explicit notion-oauth mode='your-own' → preserved (schema default is 'managed')", () => {
@@ -279,6 +293,8 @@ describe("platform-managed config defaults", () => {
           .mode,
       ).toBe("managed");
     }
+    // ...and for image-generation's provider, whose fill is "vellum".
+    expect(config.services["image-generation"].provider).toBe("vellum");
 
     // The on-disk file is NOT modified by the fill pass — disk reflects only
     // what was already there. Existing-file branch never re-writes config.json.
@@ -286,15 +302,13 @@ describe("platform-managed config defaults", () => {
     expect(onDisk["services"]).toBeUndefined();
   });
 
-  test("IS_PLATFORM=true, config file exists with a partial service subtree → preserves user fields, fills missing mode", () => {
+  test("IS_PLATFORM=true, config file exists with an explicit image-generation provider → provider wins over the vellum fill", () => {
     process.env.IS_PLATFORM = "true";
 
-    // User has an image-generation provider configured but never explicitly
-    // chose a mode for that service. The fill pass must apply
-    // `mode: "managed"` without clobbering the user-supplied provider.
-    // (The inference schema dropped per-service model/provider in
-    // migration 039 — image-generation still carries them, so it's the
-    // right schema to exercise the partial-subtree case.)
+    // User has an explicit BYOK image-generation provider on disk. The fill
+    // pass targets exactly that leaf (`provider: "vellum"`), so the explicit
+    // value must win and no mode is injected — the effective mode is the
+    // schema default.
     writeFileSync(
       CONFIG_PATH,
       JSON.stringify(
@@ -313,11 +327,11 @@ describe("platform-managed config defaults", () => {
     const imageGen = (
       config.services as unknown as Record<
         string,
-        { mode: string; provider?: string }
+        { mode?: string; provider?: string }
       >
     )["image-generation"]!;
-    expect(imageGen.mode).toBe("managed");
     expect(imageGen.provider).toBe("openai");
+    expect(imageGen).not.toHaveProperty("mode");
   });
 
   test("IS_PLATFORM=false, config file exists without services key → in-memory config keeps schema defaults (your-own except google/notion-oauth which are managed)", () => {
@@ -404,19 +418,27 @@ describe("GET /v1/config handler — context-default fill on raw response", () =
       string,
       unknown
     >;
-    const services = result["services"] as Record<string, { mode: string }>;
+    const services = result["services"] as Record<
+      string,
+      { mode?: string; provider?: string }
+    >;
     expect(services).toBeDefined();
     for (const svc of MANAGED_SERVICES) {
       expect(services[svc]!.mode).toBe("managed");
     }
+    // image-generation is filled by provider, not mode.
+    expect(services["image-generation"]!.provider).toBe("vellum");
+    expect(services["image-generation"]!.mode).toBeUndefined();
   });
 
   test("IS_PLATFORM=true, raw config has explicit services.image-generation.mode='your-own' → preserved", () => {
     process.env.IS_PLATFORM = "true";
 
-    // User has explicitly chosen "your-own" for image-generation via the macOS
-    // Save flow. The patch handler persisted that to disk; the fill pass must
-    // not override an explicit user choice.
+    // A legacy raw shape: mode with no provider leaf. Migration 134 rewrites
+    // it (pinning provider gemini) before any real request reaches this
+    // function, so the fill's only obligation here is to be non-destructive:
+    // existing keys pass through untouched, absent leaves get the platform
+    // default.
     const raw: Record<string, unknown> = {
       services: {
         "image-generation": { mode: "your-own" },
@@ -427,8 +449,12 @@ describe("GET /v1/config handler — context-default fill on raw response", () =
       string,
       unknown
     >;
-    const services = result["services"] as Record<string, { mode: string }>;
+    const services = result["services"] as Record<
+      string,
+      { mode?: string; provider?: string }
+    >;
     expect(services["image-generation"]!.mode).toBe("your-own");
+    expect(services["image-generation"]!.provider).toBe("vellum");
     // web-search is not context-filled: a filled `mode` would override BYOK
     // configs on every load.
     expect(services["web-search"]).toBeUndefined();
@@ -455,12 +481,12 @@ describe("GET /v1/config handler — context-default fill on raw response", () =
     expect(result["services"]).toBeUndefined();
   });
 
-  test("IS_PLATFORM=true, raw config has partial services subtree → preserves user fields, fills missing mode", () => {
+  test("IS_PLATFORM=true, raw config has an explicit image-generation provider → preserved, no mode injected", () => {
     process.env.IS_PLATFORM = "true";
 
-    // User set image-generation.provider but never chose a mode.
-    // The fill pass adds the missing mode without clobbering the user-supplied
-    // provider.
+    // User set image-generation.provider explicitly. The fill targets that
+    // same leaf (`provider: "vellum"`), so the explicit value wins and no
+    // mode is injected.
     const raw: Record<string, unknown> = {
       services: {
         "image-generation": { provider: "openai" },
@@ -473,10 +499,10 @@ describe("GET /v1/config handler — context-default fill on raw response", () =
     >;
     const services = result["services"] as Record<
       string,
-      { mode: string; provider?: string }
+      { mode?: string; provider?: string }
     >;
-    expect(services["image-generation"]!.mode).toBe("managed");
     expect(services["image-generation"]!.provider).toBe("openai");
+    expect(services["image-generation"]!.mode).toBeUndefined();
     // services.inference.mode is synthesized as a legacy wire-only field for
     // older macOS clients during the rollout window (Phase 1.2 schema removal
     // landed before the macOS Providers UI ships).

package/src/__tests__/config-model-image-provider.test.ts

@@ -107,3 +107,23 @@ describe("setImageGenModel — provider derived from model prefix", () => {
     expect(imageGen?.provider).toBe("openai");
   });
 });
+
+describe("setImageGenModel with provider vellum", () => {
+  test("a model change leaves provider vellum untouched", () => {
+    writeConfig({
+      services: {
+        "image-generation": { provider: "vellum", model: "gpt-image-2" },
+      },
+    });
+
+    setImageGenModel("gemini-3-pro-image-preview", makeCtx());
+
+    const raw = readConfig() as {
+      services: { "image-generation": { provider: string; model: string } };
+    };
+    expect(raw.services["image-generation"].model).toBe(
+      "gemini-3-pro-image-preview",
+    );
+    expect(raw.services["image-generation"].provider).toBe("vellum");
+  });
+});

package/src/__tests__/config-schema-memory-substrate.test.ts

@@ -0,0 +1,306 @@
+/**
+ * Tests for the `memory.substrate.*` config namespace and its resolver.
+ *
+ * The substrate schema mirrors the substrate-consumed subset of `memory.v2.*`
+ * with every field optional and no defaults; `resolveSubstrateTuning` is the
+ * single choke point that resolves each tunable from `memory.substrate` with
+ * fallback to the historical `memory.v2` key. Coverage:
+ *
+ *   - Fallback resolution: substrate unset → v2 value (defaults and explicit
+ *     values); substrate set → wins; `spread_k`/`spread_hops` map onto
+ *     `memory.v2.k`/`memory.v2.hops`; explicit `null` on a nullable substrate
+ *     key wins over a non-null v2 value.
+ *   - Namespace parsing (LUM-2758 guard): configs carrying only old keys,
+ *     only new keys, or both parse cleanly with no refinement misfires, both
+ *     through the memory slice schema and the full assistant schema.
+ *   - The substrate hybrid-weight refinement fires only when BOTH weights are
+ *     set and mis-summed.
+ *   - The parent memory schema validates the RESOLVED weight pair: a single
+ *     substrate weight is paired with its `memory.v2` twin (schema default
+ *     applied), and the effective sum must respect the sum-to-one invariant.
+ */
+import { describe, expect, test } from "bun:test";
+
+import { AssistantConfigSchema } from "../config/schema.js";
+import { MemoryConfigSchema } from "../config/schemas/memory.js";
+import { MemorySubstrateConfigSchema } from "../config/schemas/memory-substrate.js";
+import { resolveSubstrateTuning } from "../plugins/defaults/memory/substrate/tuning.js";
+
+describe("memory.substrate schema", () => {
+  test("empty object parses and every field stays unset", () => {
+    const parsed = MemorySubstrateConfigSchema.parse({});
+    expect(parsed).toEqual({});
+  });
+
+  test("memory slice parse mounts substrate as an empty object by default", () => {
+    const memory = MemoryConfigSchema.parse({});
+    expect(memory.substrate).toEqual({});
+  });
+
+  test("config with only historical memory.v2 keys parses cleanly", () => {
+    const memory = MemoryConfigSchema.parse({
+      v2: { consolidation_interval_hours: 3, bm25_k1: 1.5 },
+    });
+    expect(memory.v2.consolidation_interval_hours).toBe(3);
+    expect(memory.substrate).toEqual({});
+  });
+
+  test("config with only memory.substrate keys parses cleanly", () => {
+    const memory = MemoryConfigSchema.parse({
+      substrate: { consolidation_interval_hours: 3, spread_k: 0.4 },
+    });
+    expect(memory.substrate.consolidation_interval_hours).toBe(3);
+    expect(memory.substrate.spread_k).toBe(0.4);
+    // v2 defaults are untouched by substrate keys.
+    expect(memory.v2.consolidation_interval_hours).toBe(8);
+  });
+
+  test("config with both namespaces parses cleanly", () => {
+    const memory = MemoryConfigSchema.parse({
+      v2: { consolidation_interval_hours: 3 },
+      substrate: { consolidation_interval_hours: 5 },
+    });
+    expect(memory.v2.consolidation_interval_hours).toBe(3);
+    expect(memory.substrate.consolidation_interval_hours).toBe(5);
+  });
+
+  test("full assistant config parse accepts either, both, or neither namespace", () => {
+    for (const memory of [
+      {},
+      { v2: { max_page_chars: 4000 } },
+      { substrate: { max_page_chars: 4000 } },
+      { v2: { max_page_chars: 4000 }, substrate: { max_page_chars: 6000 } },
+    ]) {
+      const result = AssistantConfigSchema.safeParse({ memory });
+      expect(result.success).toBe(true);
+    }
+  });
+
+  test("hybrid-weight refinement fires only when both weights are set and mis-summed", () => {
+    // Only one weight set — no refinement at the substrate schema level; the
+    // parent memory schema validates the resolved pair against the v2 twin.
+    expect(
+      MemorySubstrateConfigSchema.safeParse({ dense_weight: 0.5 }).success,
+    ).toBe(true);
+    expect(
+      MemorySubstrateConfigSchema.safeParse({ sparse_weight: 0.5 }).success,
+    ).toBe(true);
+
+    // Both set and summing to 1.0 — valid.
+    expect(
+      MemorySubstrateConfigSchema.safeParse({
+        dense_weight: 0.7,
+        sparse_weight: 0.3,
+      }).success,
+    ).toBe(true);
+
+    // Both set and mis-summed — one issue per contributing field.
+    const bad = MemorySubstrateConfigSchema.safeParse({
+      dense_weight: 0.7,
+      sparse_weight: 0.7,
+    });
+    expect(bad.success).toBe(false);
+    if (!bad.success) {
+      const paths = bad.error.issues.map((issue) => issue.path.join("."));
+      expect(paths.sort()).toEqual(["dense_weight", "sparse_weight"]);
+      expect(bad.error.issues[0].message).toContain(
+        "memory.substrate hybrid weights",
+      );
+    }
+  });
+
+  describe("resolved hybrid-weight invariant (memory schema level)", () => {
+    // Parses `memory` through both entry points that must agree: the memory
+    // slice schema and the full assistant config schema.
+    const parseBothWays = (memory: unknown) => ({
+      slice: MemoryConfigSchema.safeParse(memory),
+      full: AssistantConfigSchema.safeParse({ memory }),
+    });
+
+    test("a lone substrate dense_weight that breaks the effective sum is rejected", () => {
+      // v2 sparse_weight defaults to 0.15 → effective sum 1.05.
+      const { slice, full } = parseBothWays({
+        substrate: { dense_weight: 0.9 },
+      });
+      for (const result of [slice, full]) {
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          const issue = result.error.issues.find((candidate) =>
+            candidate.message.includes(
+              "memory hybrid weights must sum to 1.0 after memory.substrate → memory.v2 fallback",
+            ),
+          );
+          expect(issue).toBeDefined();
+          expect(issue?.message).toContain("0.9000");
+          expect(issue?.message).toContain("0.1500");
+          expect(issue?.message).toContain("1.0500");
+          expect(issue?.path.slice(-2)).toEqual(["substrate", "dense_weight"]);
+        }
+      }
+    });
+
+    test("a lone substrate sparse_weight that breaks the effective sum is rejected", () => {
+      // v2 dense_weight defaults to 0.85 → effective sum 1.35.
+      const { slice, full } = parseBothWays({
+        substrate: { sparse_weight: 0.5 },
+      });
+      for (const result of [slice, full]) {
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          const issue = result.error.issues.find((candidate) =>
+            candidate.message.includes(
+              "memory hybrid weights must sum to 1.0 after memory.substrate → memory.v2 fallback",
+            ),
+          );
+          expect(issue).toBeDefined();
+          expect(issue?.path.slice(-2)).toEqual(["substrate", "sparse_weight"]);
+        }
+      }
+    });
+
+    test("a complete substrate pair summing to 1.0 is accepted", () => {
+      const { slice, full } = parseBothWays({
+        substrate: { dense_weight: 0.9, sparse_weight: 0.1 },
+      });
+      expect(slice.success).toBe(true);
+      expect(full.success).toBe(true);
+    });
+
+    test("a lone substrate weight matching the v2 default pair is accepted", () => {
+      // 0.85 pairs with the v2 sparse_weight default 0.15 → effective sum 1.0.
+      const { slice, full } = parseBothWays({
+        substrate: { dense_weight: 0.85 },
+      });
+      expect(slice.success).toBe(true);
+      expect(full.success).toBe(true);
+    });
+
+    test("a lone substrate weight pairing with an explicit v2 twin is accepted", () => {
+      const { slice, full } = parseBothWays({
+        v2: { dense_weight: 0.7, sparse_weight: 0.3 },
+        substrate: { sparse_weight: 0.3 },
+      });
+      expect(slice.success).toBe(true);
+      expect(full.success).toBe(true);
+    });
+
+    test("a mis-summed complete substrate pair only fires the substrate refinement", () => {
+      // Both substrate weights set → the parent check skips; only the
+      // substrate schema's own refinement reports, so the two never
+      // contradict each other.
+      const { slice, full } = parseBothWays({
+        substrate: { dense_weight: 0.7, sparse_weight: 0.7 },
+      });
+      for (const result of [slice, full]) {
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          const messages = result.error.issues.map((issue) => issue.message);
+          expect(
+            messages.some((message) =>
+              message.includes("memory.substrate hybrid weights"),
+            ),
+          ).toBe(true);
+          expect(
+            messages.some((message) =>
+              message.includes(
+                "memory hybrid weights must sum to 1.0 after memory.substrate → memory.v2 fallback",
+              ),
+            ),
+          ).toBe(false);
+        }
+      }
+    });
+  });
+});
+
+describe("resolveSubstrateTuning", () => {
+  test("substrate unset resolves to the v2 schema defaults", () => {
+    const memory = MemoryConfigSchema.parse({});
+    const tuning = resolveSubstrateTuning(memory);
+    expect(tuning).toEqual({
+      sweep_enabled: false,
+      dense_weight: 0.85,
+      sparse_weight: 0.15,
+      min_sparse_spread: undefined,
+      full_sparse_spread: undefined,
+      bm25_k1: 1.2,
+      bm25_b: 0.4,
+      consolidation_interval_hours: 8,
+      consolidation_max_buffer_lines: 100,
+      consolidation_max_entries_per_run: 150,
+      max_page_chars: 5000,
+      consolidation_prompt_path: null,
+      spread_k: 0.5,
+      spread_hops: 2,
+      ann_candidate_limit: null,
+    });
+  });
+
+  test("substrate unset resolves to explicitly-set v2 values", () => {
+    const memory = MemoryConfigSchema.parse({
+      v2: {
+        sweep_enabled: true,
+        consolidation_interval_hours: 3,
+        consolidation_max_buffer_lines: null,
+        bm25_b: 0.9,
+      },
+    });
+    const tuning = resolveSubstrateTuning(memory);
+    expect(tuning.sweep_enabled).toBe(true);
+    expect(tuning.consolidation_interval_hours).toBe(3);
+    expect(tuning.consolidation_max_buffer_lines).toBeNull();
+    expect(tuning.bm25_b).toBe(0.9);
+  });
+
+  test("a set substrate key wins over the v2 twin", () => {
+    const memory = MemoryConfigSchema.parse({
+      v2: {
+        consolidation_interval_hours: 3,
+        max_page_chars: 4000,
+        sweep_enabled: true,
+      },
+      substrate: {
+        consolidation_interval_hours: 12,
+        max_page_chars: 9000,
+        sweep_enabled: false,
+      },
+    });
+    const tuning = resolveSubstrateTuning(memory);
+    expect(tuning.consolidation_interval_hours).toBe(12);
+    expect(tuning.max_page_chars).toBe(9000);
+    expect(tuning.sweep_enabled).toBe(false);
+  });
+
+  test("spread_k / spread_hops map onto memory.v2.k / memory.v2.hops", () => {
+    const fallback = resolveSubstrateTuning(
+      MemoryConfigSchema.parse({ v2: { k: 0.7, hops: 4 } }),
+    );
+    expect(fallback.spread_k).toBe(0.7);
+    expect(fallback.spread_hops).toBe(4);
+
+    const overridden = resolveSubstrateTuning(
+      MemoryConfigSchema.parse({
+        v2: { k: 0.7, hops: 4 },
+        substrate: { spread_k: 0.2, spread_hops: 1 },
+      }),
+    );
+    expect(overridden.spread_k).toBe(0.2);
+    expect(overridden.spread_hops).toBe(1);
+  });
+
+  test("an explicit substrate null wins over a non-null v2 value", () => {
+    const memory = MemoryConfigSchema.parse({
+      v2: {
+        ann_candidate_limit: 500,
+        consolidation_max_entries_per_run: 50,
+      },
+      substrate: {
+        ann_candidate_limit: null,
+        consolidation_max_entries_per_run: null,
+      },
+    });
+    const tuning = resolveSubstrateTuning(memory);
+    expect(tuning.ann_candidate_limit).toBeNull();
+    expect(tuning.consolidation_max_entries_per_run).toBeNull();
+  });
+});

package/src/__tests__/config-schema.test.ts

@@ -68,7 +68,7 @@ describe("AssistantConfigSchema", () => {
     expect(result.services["image-generation"].model).toBe(
       "gemini-3.1-flash-image-preview",
     );
-    expect(result.services["image-generation"].mode).toBe("your-own");
+    expect(result.services["image-generation"]).not.toHaveProperty("mode");
     expect(result.services["web-search"].provider).toBe(
       "inference-provider-native",
     );
@@ -99,6 +99,17 @@ describe("AssistantConfigSchema", () => {
     expect(result.auditLog).toEqual({ retentionDays: 0 });
   });
 
+  test("accepts vellum as an image generation provider", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        "image-generation": { provider: "vellum", model: "gpt-image-2" },
+      },
+    });
+
+    expect(result.services["image-generation"].provider).toBe("vellum");
+    expect(result.services["image-generation"].model).toBe("gpt-image-2");
+  });
+
   test("accepts Tavily as a web search provider", () => {
     const result = AssistantConfigSchema.parse({
       services: {
@@ -928,11 +939,12 @@ describe("AssistantConfigSchema", () => {
         endpointMaxExtensions: 2,
         ackFirstDeltaTimeoutMs: 2500,
         ackGenerationTimeoutMs: 600,
-        llmAckText: false,
         progress: {
           enabled: true,
           opsThreshold: 3,
           idleIntervalMs: 5000,
+          maxSilenceMs: 35000,
+          longOpMs: 15000,
           minGapMs: 6000,
           generationTimeoutMs: 1500,
         },

package/src/__tests__/config-set-platform-guard.test.ts

@@ -174,8 +174,10 @@ describe("config set - platform connection guard for service mode paths", () =>
     mockIpcResult = { ok: true, result: { ok: true } };
   });
 
-  test("config set services.image-generation.mode your-own - succeeds without platform connection", async () => {
-    const { exitCode } = await runCli([
+  test("config set services.image-generation.mode - rejected with provider guidance, no IPC write emitted", async () => {
+    // The image-generation schema has no mode field; a raw write would be
+    // stripped at parse while the CLI reported success.
+    const { exitCode, stdout } = await runCli([
       "node",
       "assistant",
       "--json",
@@ -185,16 +187,13 @@ describe("config set - platform connection guard for service mode paths", () =>
       "your-own",
     ]);
 
-    expect(exitCode).toBe(0);
-    // The CLI should have emitted exactly one config_set IPC call.
-    const setCalls = mockIpcCalls.filter((c) => c.method === "config_set");
-    expect(setCalls).toHaveLength(1);
-    expect(setCalls[0]!.params).toEqual({
-      body: {
-        path: "services.image-generation.mode",
-        value: "your-own",
-      },
-    });
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("services.image-generation.provider vellum");
+    expect(mockIpcCalls.filter((c) => c.method === "config_set")).toHaveLength(
+      0,
+    );
   });
 
   test("config set calls.enabled true - succeeds without platform connection and parses to boolean", async () => {