@vellumai/assistant 0.7.1 → 0.7.2

package/src/__tests__/config-loader-backfill.test.ts

@@ -1,6 +1,7 @@
 import {
   existsSync,
   mkdirSync,
+  readdirSync,
   readFileSync,
   rmSync,
   writeFileSync,
@@ -64,8 +65,8 @@ afterAll(() => {
 });
 
 import {
-  deepMergeMissing,
   deepMergeOverwrite,
+  getConfig,
   invalidateConfigCache,
   loadConfig,
 } from "../config/loader.js";
@@ -79,73 +80,11 @@ function writeConfig(obj: unknown): void {
   writeFileSync(CONFIG_PATH, JSON.stringify(obj, null, 2) + "\n");
 }
 
-function readConfig(): Record<string, unknown> {
-  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
-}
-
-// ---------------------------------------------------------------------------
-// Tests: deepMergeMissing (unit)
-// ---------------------------------------------------------------------------
-
-describe("deepMergeMissing", () => {
-  test("adds missing top-level keys", () => {
-    const target: Record<string, unknown> = { a: 1 };
-    const defaults: Record<string, unknown> = { a: 99, b: 2 };
-    const changed = deepMergeMissing(target, defaults);
-    expect(changed).toBe(true);
-    expect(target).toEqual({ a: 1, b: 2 });
-  });
-
-  test("does not overwrite existing values", () => {
-    const target: Record<string, unknown> = { a: 1, b: "user" };
-    const defaults: Record<string, unknown> = { a: 99, b: "default" };
-    const changed = deepMergeMissing(target, defaults);
-    expect(changed).toBe(false);
-    expect(target).toEqual({ a: 1, b: "user" });
-  });
-
-  test("recursively fills nested objects", () => {
-    const target: Record<string, unknown> = {
-      nested: { existingKey: "keep" },
-    };
-    const defaults: Record<string, unknown> = {
-      nested: { existingKey: "default", newKey: 42 },
-    };
-    const changed = deepMergeMissing(target, defaults);
-    expect(changed).toBe(true);
-    expect(target).toEqual({
-      nested: { existingKey: "keep", newKey: 42 },
-    });
-  });
-
-  test("returns false when no changes needed", () => {
-    const target: Record<string, unknown> = { a: 1, b: { c: 3 } };
-    const defaults: Record<string, unknown> = { a: 99, b: { c: 100 } };
-    const changed = deepMergeMissing(target, defaults);
-    expect(changed).toBe(false);
-  });
-
-  test("does not merge arrays", () => {
-    const target: Record<string, unknown> = { items: [1, 2] };
-    const defaults: Record<string, unknown> = { items: [3, 4, 5] };
-    const changed = deepMergeMissing(target, defaults);
-    expect(changed).toBe(false);
-    expect(target).toEqual({ items: [1, 2] });
-  });
-
-  test("adds entire missing nested section", () => {
-    const target: Record<string, unknown> = {};
-    const defaults: Record<string, unknown> = {
-      slack: { deliverAuthBypass: false },
-    };
-    const changed = deepMergeMissing(target, defaults);
-    expect(changed).toBe(true);
-    expect(target).toEqual({ slack: { deliverAuthBypass: false } });
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Tests: deepMergeOverwrite (unit) — JSON-null-as-deletion semantics
+//
+// `deepMergeOverwrite` is used by `mergeDefaultWorkspaceConfig` and platform
+// override paths.
 // ---------------------------------------------------------------------------
 
 describe("deepMergeOverwrite", () => {
@@ -275,7 +214,11 @@ describe("deepMergeOverwrite", () => {
       heartbeat: { activeHoursStart: null, activeHoursEnd: null },
     });
     expect(target).toEqual({
-      heartbeat: { intervalMs: 6000, activeHoursStart: null, activeHoursEnd: null },
+      heartbeat: {
+        intervalMs: 6000,
+        activeHoursStart: null,
+        activeHoursEnd: null,
+      },
     });
   });
 
@@ -318,10 +261,15 @@ describe("deepMergeOverwrite", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Tests: startup backfill integration
+// Tests: loadConfig() startup behavior
+//
+// Contract: disk = user intent, in-memory cache = effective values. loadConfig
+// must NOT silently materialize schema defaults into config.json on load.
+// The legitimate self-healing paths that DO rewrite the file (deprecated-key
+// strip, fresh-config seed, corrupt-JSON quarantine) are protected below.
 // ---------------------------------------------------------------------------
 
-describe("config loader backfill", () => {
+describe("loadConfig startup behavior", () => {
   beforeEach(() => {
     ensureTestDir();
     const resetPaths = [
@@ -335,6 +283,16 @@ describe("config loader backfill", () => {
         rmSync(path, { recursive: true, force: true });
       }
     }
+    // Also clear any leftover quarantine files from previous test runs.
+    if (existsSync(WORKSPACE_DIR)) {
+      for (const entry of readdirSync(WORKSPACE_DIR)) {
+        if (entry.startsWith("config.json.corrupt-")) {
+          rmSync(join(WORKSPACE_DIR, entry), { force: true });
+        }
+      }
+    }
+    const updatesPath = join(WORKSPACE_DIR, "UPDATES.md");
+    if (existsSync(updatesPath)) rmSync(updatesPath, { force: true });
     ensureTestDir();
     _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
@@ -345,119 +303,96 @@ describe("config loader backfill", () => {
     invalidateConfigCache();
   });
 
-  test("backfills missing schema keys into existing config.json", () => {
-    // Write a minimal config that is missing many sections
-    writeConfig({ provider: "anthropic", model: "claude-opus-4-6" });
+  test("does not modify existing config.json on load", () => {
+    // Write a partial config and confirm the file's bytes are unchanged
+    // after loadConfig(). Schema defaults must apply in-memory only; disk
+    // is the user's source of truth.
+    writeConfig({ provider: "anthropic" });
+    const before = readFileSync(CONFIG_PATH);
 
     loadConfig();
 
-    // Re-read the file from disk — it should have been backfilled
-    const raw = readConfig();
-    // New fields from this PR should be present
-    expect(raw.telegram).toBeDefined();
-    expect((raw.telegram as Record<string, unknown>).apiBaseUrl).toBe(
-      "https://api.telegram.org",
-    );
-    expect((raw.telegram as Record<string, unknown>).deliverAuthBypass).toBe(
-      false,
-    );
-    expect((raw.telegram as Record<string, unknown>).timeoutMs).toBe(15_000);
-    expect((raw.telegram as Record<string, unknown>).maxRetries).toBe(3);
-    expect((raw.telegram as Record<string, unknown>).initialBackoffMs).toBe(
-      1_000,
-    );
+    const after = readFileSync(CONFIG_PATH);
+    expect(after.equals(before)).toBe(true);
+  });
 
-    expect(raw.whatsapp).toBeDefined();
-    expect((raw.whatsapp as Record<string, unknown>).deliverAuthBypass).toBe(
-      false,
-    );
-    expect((raw.whatsapp as Record<string, unknown>).timeoutMs).toBe(15_000);
-    expect((raw.whatsapp as Record<string, unknown>).maxRetries).toBe(3);
-    expect((raw.whatsapp as Record<string, unknown>).initialBackoffMs).toBe(
-      1_000,
-    );
+  test("getConfig().memory.v2.bm25_b returns schema default when absent on disk", () => {
+    // Consumer-side correctness: even though loadConfig no longer writes
+    // schema defaults back to disk, accessors still see them via the
+    // in-memory `cached: AssistantConfig` populated by `applyNestedDefaults`.
+    writeConfig({ provider: "anthropic" });
 
-    expect(raw.slack).toBeDefined();
-    expect((raw.slack as Record<string, unknown>).deliverAuthBypass).toBe(
-      false,
-    );
+    const config = getConfig();
+
+    expect(config.memory.v2.bm25_b).toBe(0.4);
   });
 
-  test("preserves existing user-defined values during backfill", () => {
+  test("still strips deprecated fields and rewrites", () => {
+    // `warnAndStripDeprecatedFields` is a legitimate self-healing path:
+    // it removes fields the schema no longer recognizes and persists the
+    // cleaned config so the deprecation warning fires only once.
     writeConfig({
-      services: {
-        inference: { provider: "openai", model: "gpt-4" },
-      },
-      telegram: { botUsername: "mybot", timeoutMs: 30_000 },
-      whatsapp: { phoneNumber: "+1234567890" },
+      provider: "anthropic",
+      rateLimit: { maxTokensPerSession: 100_000 },
     });
 
     loadConfig();
 
-    const raw = readConfig();
-    // User values preserved
-    const services = raw.services as Record<string, Record<string, unknown>>;
-    expect(services.inference.provider).toBe("openai");
-    expect(services.inference.model).toBe("gpt-4");
-    expect((raw.telegram as Record<string, unknown>).botUsername).toBe("mybot");
-    expect((raw.telegram as Record<string, unknown>).timeoutMs).toBe(30_000);
-    expect((raw.whatsapp as Record<string, unknown>).phoneNumber).toBe(
-      "+1234567890",
-    );
-
-    // Missing fields backfilled
-    expect((raw.telegram as Record<string, unknown>).apiBaseUrl).toBe(
-      "https://api.telegram.org",
-    );
-    expect((raw.telegram as Record<string, unknown>).deliverAuthBypass).toBe(
-      false,
-    );
-    expect((raw.whatsapp as Record<string, unknown>).deliverAuthBypass).toBe(
-      false,
-    );
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    expect(raw.rateLimit?.maxTokensPerSession).toBeUndefined();
+    // Other rateLimit keys are not affected — only the deprecated entry is stripped
+    expect(raw.provider).toBe("anthropic");
   });
 
-  test("does not rewrite config.json when no effective change exists", () => {
-    // First load: creates config from scratch with all defaults
-    loadConfig();
-    invalidateConfigCache();
-
-    // Read file and record its content
-    const contentBefore = readFileSync(CONFIG_PATH, "utf-8");
+  test("strips memory.jobs.batchSize from existing user configs", () => {
+    // Pre-PR-#29364, the memory job worker read `memory.jobs.batchSize` to
+    // size its single claim batch. The per-lane scheduler no longer reads
+    // it, so the field is deprecated. Existing configs that have it
+    // written to disk should load cleanly with the field silently stripped.
+    writeConfig({
+      provider: "anthropic",
+      memory: { jobs: { batchSize: 25, workerConcurrency: 4 } },
+    });
 
-    // Second load: file already has all keys — no write expected
     loadConfig();
 
-    const contentAfter = readFileSync(CONFIG_PATH, "utf-8");
-    expect(contentAfter).toBe(contentBefore);
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    expect(raw.memory?.jobs?.batchSize).toBeUndefined();
+    // Sibling fields under memory.jobs are preserved
+    expect(raw.memory?.jobs?.workerConcurrency).toBe(4);
   });
 
-  test("does not write dataDir during backfill", () => {
-    writeConfig({ provider: "anthropic" });
+  test("still writes a default config on first launch when file is absent", () => {
+    // Discoverability: when no config.json exists, write one populated with
+    // all schema defaults so users can see and edit available options.
+    expect(existsSync(CONFIG_PATH)).toBe(false);
 
     loadConfig();
 
-    const raw = readConfig();
+    expect(existsSync(CONFIG_PATH)).toBe(true);
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    // Sanity: schema-defaulted nested fields are materialized
+    expect(raw.memory?.v2?.bm25_b).toBe(0.4);
     expect(raw.dataDir).toBeUndefined();
   });
 
-  test("backfills new nested fields into existing sections", () => {
-    // Config with only the old telegram.botUsername field
-    writeConfig({
-      telegram: { botUsername: "oldbot" },
-    });
+  test("still quarantines corrupt JSON", () => {
+    // Corrupt-config quarantine is a recovery path: the broken file is
+    // renamed to `config.json.corrupt-<ts>.json` and the daemon proceeds
+    // with defaults. This must keep working.
+    writeFileSync(CONFIG_PATH, "{not valid json");
 
     loadConfig();
 
-    const raw = readConfig();
-    const telegram = raw.telegram as Record<string, unknown>;
-    // Old field preserved
-    expect(telegram.botUsername).toBe("oldbot");
-    // New fields backfilled
-    expect(telegram.apiBaseUrl).toBe("https://api.telegram.org");
-    expect(telegram.deliverAuthBypass).toBe(false);
-    expect(telegram.timeoutMs).toBe(15_000);
-    expect(telegram.maxRetries).toBe(3);
-    expect(telegram.initialBackoffMs).toBe(1_000);
+    // A new defaults-populated config.json is written in place
+    expect(existsSync(CONFIG_PATH)).toBe(true);
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    expect(raw.memory?.v2?.bm25_b).toBe(0.4);
+
+    // The corrupt original is preserved as a `*.corrupt-*.json` sibling
+    const quarantined = readdirSync(WORKSPACE_DIR).filter((n) =>
+      n.startsWith("config.json.corrupt-"),
+    );
+    expect(quarantined.length).toBeGreaterThan(0);
   });
 });

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

@@ -0,0 +1,196 @@
+/**
+ * When IS_PLATFORM=true and no config.json exists yet, loadConfig() must
+ * write all eight managed-capable service modes as "managed" instead of the
+ * schema default "your-own". When IS_PLATFORM is absent/false, or when
+ * config.json already exists, the schema defaults and existing values are
+ * preserved unchanged.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — declared before imports that depend on platform/logger
+// ---------------------------------------------------------------------------
+
+const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+afterAll(() => {
+  mock.restore();
+});
+
+import { invalidateConfigCache, loadConfig } from "../config/loader.js";
+import { _setStorePath } from "../security/encrypted-store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function ensureTestDir(): void {
+  const dirs = [
+    WORKSPACE_DIR,
+    join(WORKSPACE_DIR, "data"),
+    join(WORKSPACE_DIR, "data", "memory"),
+    join(WORKSPACE_DIR, "data", "memory", "knowledge"),
+    join(WORKSPACE_DIR, "data", "logs"),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+}
+
+function resetWorkspace(): void {
+  if (existsSync(WORKSPACE_DIR)) {
+    for (const name of readdirSync(WORKSPACE_DIR)) {
+      rmSync(join(WORKSPACE_DIR, name), { recursive: true, force: true });
+    }
+  }
+  ensureTestDir();
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+}
+
+const MANAGED_SERVICES = [
+  "inference",
+  "image-generation",
+  "web-search",
+  "google-oauth",
+  "outlook-oauth",
+  "linear-oauth",
+  "github-oauth",
+  "notion-oauth",
+] as const;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("platform-managed config defaults", () => {
+  const originalIsPlatform = process.env.IS_PLATFORM;
+
+  beforeEach(() => {
+    resetWorkspace();
+    _setStorePath(join(WORKSPACE_DIR, "keys.enc"));
+    invalidateConfigCache();
+  });
+
+  afterEach(() => {
+    _setStorePath(null);
+    invalidateConfigCache();
+    // Restore env to its original value
+    if (originalIsPlatform === undefined) {
+      delete process.env.IS_PLATFORM;
+    } else {
+      process.env.IS_PLATFORM = originalIsPlatform;
+    }
+  });
+
+  test("IS_PLATFORM=true, no config file → all 8 service modes written as 'managed'", () => {
+    process.env.IS_PLATFORM = "true";
+
+    loadConfig();
+
+    expect(existsSync(CONFIG_PATH)).toBe(true);
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    const services = written.services!;
+    for (const svc of MANAGED_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("managed");
+    }
+  });
+
+  test("IS_PLATFORM=false, no config file → service modes default to 'your-own'", () => {
+    process.env.IS_PLATFORM = "false";
+
+    loadConfig();
+
+    expect(existsSync(CONFIG_PATH)).toBe(true);
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    const services = written.services!;
+    for (const svc of MANAGED_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("your-own");
+    }
+  });
+
+  test("IS_PLATFORM unset, no config file → service modes default to 'your-own'", () => {
+    delete process.env.IS_PLATFORM;
+
+    loadConfig();
+
+    expect(existsSync(CONFIG_PATH)).toBe(true);
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    const services = written.services!;
+    for (const svc of MANAGED_SERVICES) {
+      expect((services[svc] as { mode?: string })?.mode).toBe("your-own");
+    }
+  });
+
+  test("IS_PLATFORM=true, config file already exists → existing service mode values are preserved", () => {
+    process.env.IS_PLATFORM = "true";
+
+    // Write an existing config with inference mode explicitly set to "your-own"
+    writeFileSync(
+      CONFIG_PATH,
+      JSON.stringify(
+        {
+          services: {
+            inference: { mode: "your-own" },
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+
+    loadConfig();
+
+    const written = readConfig() as { services?: Record<string, unknown> };
+    expect(written.services).toBeDefined();
+    // The existing value must be preserved — backfill path, not fresh-write path
+    expect(
+      (written.services!["inference"] as { mode?: string })?.mode,
+    ).toBe("your-own");
+  });
+});

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

@@ -63,7 +63,6 @@ mock.module("../config/loader.js", () => ({
   }),
   loadConfig: () => ({}),
   loadRawConfig: () => ({}),
-  saveConfig: () => {},
   saveRawConfig: () => {},
   invalidateConfigCache: () => {},
   getNestedValue: () => undefined,

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

@@ -40,20 +40,37 @@ mock.module("../platform/client.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({ services: {} }),
   loadConfig: () => ({ services: {} }),
-  saveConfig: () => {},
   invalidateConfigCache: () => {},
   loadRawConfig: () => mockLoadRawConfig(),
   saveRawConfig: (raw: Record<string, unknown>) => {
     mockSaveRawConfigCalls.push(raw);
   },
   applyNestedDefaults: (c: unknown) => c,
-  deepMergeMissing: (a: unknown) => a,
   deepMergeOverwrite: (a: unknown) => a,
   mergeDefaultWorkspaceConfig: () => {},
   getNestedValue: (obj: Record<string, unknown>, key: string) =>
     mockGetNestedValue(obj, key),
-  setNestedValue: (obj: Record<string, unknown>, key: string, value: unknown) =>
-    mockSetNestedValueCalls.push({ obj, key, value }),
+  setNestedValue: (
+    obj: Record<string, unknown>,
+    key: string,
+    value: unknown,
+  ) => {
+    mockSetNestedValueCalls.push({ obj, key, value });
+    const keys = key.split(".");
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const segment = keys[i]!;
+      if (
+        current[segment] == null ||
+        typeof current[segment] !== "object" ||
+        Array.isArray(current[segment])
+      ) {
+        current[segment] = {};
+      }
+      current = current[segment] as Record<string, unknown>;
+    }
+    current[keys[keys.length - 1]!] = value;
+  },
   API_KEY_PROVIDERS: [
     "anthropic",
     "openai",
@@ -240,6 +257,33 @@ describe("config set — platform connection guard for service mode paths", () =
     expect(mockSaveRawConfigCalls).toHaveLength(1);
   });
 
+  test("config set ingress.publicBaseUrl overwrites existing value", async () => {
+    mockLoadRawConfig = () => ({
+      ingress: {
+        publicBaseUrl: "https://stale-velay.example.test",
+        publicBaseUrlManagedBy: "velay",
+      },
+    });
+
+    const { exitCode } = await runCli([
+      "node",
+      "assistant",
+      "config",
+      "set",
+      "ingress.publicBaseUrl",
+      "https://manual.example.test",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(mockSaveRawConfigCalls).toHaveLength(1);
+    expect(mockSaveRawConfigCalls[0]).toEqual({
+      ingress: {
+        publicBaseUrl: "https://manual.example.test",
+        publicBaseUrlManagedBy: "velay",
+      },
+    });
+  });
+
   test("config get services.inference.mode — works without platform connection", async () => {
     mockGetNestedValue = (_obj, key) => {
       if (key === "services.inference.mode") return "your-own";

package/src/__tests__/config-watcher-cleanup-throttle.test.ts

@@ -215,8 +215,8 @@ mock.module("../signals/emit-event.js", () => ({
   handleEmitEventSignal: () => {},
 }));
 
-mock.module("../signals/mcp-reload.js", () => ({
-  handleMcpReloadSignal: () => {},
+mock.module("../daemon/mcp-reload-service.js", () => ({
+  reloadMcpServers: async () => {},
 }));
 
 mock.module("../signals/user-message.js", () => ({

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

@@ -92,8 +92,8 @@ mock.module("../providers/registry.js", () => ({
   initializeProviders: () => {},
 }));
 
-mock.module("../signals/mcp-reload.js", () => ({
-  handleMcpReloadSignal: () => {},
+mock.module("../daemon/mcp-reload-service.js", () => ({
+  reloadMcpServers: async () => {},
 }));
 
 mock.module("../signals/conversation-undo.js", () => ({