@vellumai/assistant 0.7.0 → 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-schema.test.ts

@@ -57,10 +57,12 @@ import { invalidateConfigCache, loadConfig } from "../config/loader.js";
 import {
   AssistantConfigSchema,
   DEFAULT_ELEVENLABS_VOICE_ID,
-  SttServiceSchema,
-  TtsServiceSchema,
-  VALID_TTS_SERVICE_PROVIDERS,
 } from "../config/schema.js";
+import { SttServiceSchema } from "../config/schemas/stt.js";
+import {
+  TtsServiceSchema,
+  VALID_TTS_PROVIDERS as VALID_TTS_SERVICE_PROVIDERS,
+} from "../config/schemas/tts.js";
 import type { AssistantConfig } from "../config/types.js";
 import { _setStorePath } from "../security/encrypted-store.js";
 import { listCatalogProviderIds } from "../tts/provider-catalog.js";
@@ -126,9 +128,7 @@ describe("AssistantConfigSchema", () => {
     });
     expect(result.secretDetection).toEqual({
       enabled: true,
-      action: "redact",
       blockIngress: true,
-      entropyThreshold: 4.0,
       allowOneTimeSend: false,
     });
     expect(result.auditLog).toEqual({ retentionDays: 0 });
@@ -151,9 +151,7 @@ describe("AssistantConfigSchema", () => {
       rateLimit: { maxRequestsPerMinute: 10 },
       secretDetection: {
         enabled: false,
-        action: "block" as const,
         blockIngress: false,
-        entropyThreshold: 5.5,
       },
       auditLog: { retentionDays: 30 },
     };
@@ -162,7 +160,7 @@ describe("AssistantConfigSchema", () => {
     expect(result.llm.default.model).toBe("gpt-4");
     expect(result.llm.default.maxTokens).toBe(4096);
     expect(result.llm.default.thinking.enabled).toBe(true);
-    expect(result.secretDetection.action).toBe("block");
+    expect(result.secretDetection.enabled).toBe(false);
   });
 
   test("applies llm defaults when llm key is omitted", () => {
@@ -577,24 +575,6 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("rejects invalid secretDetection.action", () => {
-    const result = AssistantConfigSchema.safeParse({
-      secretDetection: { action: "explode" },
-    });
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      const msgs = result.error.issues.map((i) => i.message);
-      expect(msgs.some((m) => m.includes("secretDetection.action"))).toBe(true);
-    }
-  });
-
-  test("rejects negative secretDetection.entropyThreshold", () => {
-    const result = AssistantConfigSchema.safeParse({
-      secretDetection: { entropyThreshold: -1 },
-    });
-    expect(result.success).toBe(false);
-  });
-
   test("rejects negative rateLimit values", () => {
     const result = AssistantConfigSchema.safeParse({
       rateLimit: { maxRequestsPerMinute: -1 },
@@ -641,19 +621,9 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("accepts all valid secretDetection.action values", () => {
-    for (const action of ["redact", "warn", "block"] as const) {
-      const result = AssistantConfigSchema.safeParse({
-        secretDetection: { action },
-      });
-      expect(result.success).toBe(true);
-    }
-  });
-
   test("provides helpful error messages", () => {
     const result = AssistantConfigSchema.safeParse({
       llm: { default: { maxTokens: -1 } },
-      secretDetection: { action: "explode" },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
@@ -665,12 +635,6 @@ describe("AssistantConfigSchema", () => {
           (m) => m.includes("positive") || /expected number to be >0/i.test(m),
         ),
       ).toBe(true);
-      expect(
-        messages.some(
-          (m) =>
-            m.includes("redact") && m.includes("warn") && m.includes("block"),
-        ),
-      ).toBe(true);
     }
   });
 
@@ -2179,12 +2143,6 @@ describe("loadConfig with schema validation", () => {
     expect(config.timeouts.permissionTimeoutSec).toBe(300);
   });
 
-  test("falls back for invalid secretDetection.action", () => {
-    writeConfig({ secretDetection: { action: "explode" } });
-    const config = loadConfig();
-    expect(config.secretDetection.action).toBe("redact");
-  });
-
   test("falls back for invalid contextWindow relationship", () => {
     writeConfig({
       llm: {