@vellumai/assistant 0.10.3-dev.202606300531.247eff8 → 0.10.3-dev.202606300731.35e9ab8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606300531.247eff8",
+  "version": "0.10.3-dev.202606300731.35e9ab8",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/generate-openapi.ts

@@ -16,7 +16,7 @@
  *   cd assistant && bun run generate:openapi -- --check  # CI: fail if stale
  */
 
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { readdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 
@@ -32,6 +32,7 @@ import { createDocument } from "zod-openapi";
 
 const ROOT = resolve(import.meta.dir, "..");
 const ROUTES_DIR = join(ROOT, "src/runtime/routes");
+const PLUGIN_DEFAULTS_DIR = join(ROOT, "src/plugins/defaults");
 const OUTPUT_PATH = join(ROOT, "openapi.yaml");
 const PKG_PATH = join(ROOT, "package.json");
 
@@ -147,68 +148,89 @@ function resolveSchemaForDocument(schemaSource: unknown): ContentSchema {
 // ---------------------------------------------------------------------------
 
 /**
- * Dynamically import every route module under `src/runtime/routes/`
- * and collect all exported `ROUTES` arrays.
- *
- * Each route module is expected to export a `ROUTES: RouteDefinition[]`
- * constant. The function automatically picks up new route modules
- * without manual updates.
+ * Directories holding `RouteDefinition` modules: the host `runtime/routes`
+ * tree plus every default plugin's `routes/` subdirectory. A default plugin
+ * that owns model-facing HTTP/IPC routes defines them under
+ * `plugins/defaults/<plugin>/routes/` and the host route aggregator registers
+ * them at runtime; the generator scans those dirs too so the spec stays
+ * complete no matter which package a route lives in. Sorted for reproducible
+ * output (see {@link collectRoutesFromModules}).
+ */
+async function routeModuleDirs(): Promise<string[]> {
+  const dirs = [ROUTES_DIR];
+  for (const entry of await readdir(PLUGIN_DEFAULTS_DIR, {
+    withFileTypes: true,
+  })) {
+    if (!entry.isDirectory()) continue;
+    const routesDir = join(PLUGIN_DEFAULTS_DIR, entry.name, "routes");
+    if (existsSync(routesDir)) dirs.push(routesDir);
+  }
+  return dirs.sort();
+}
+
+/**
+ * Dynamically import every route module under each {@link routeModuleDirs}
+ * entry and collect all exported `ROUTES` / `*_ROUTES` arrays. Each route
+ * module exports a `RouteDefinition[]`; new modules are picked up without
+ * manual updates.
  */
 async function collectRoutesFromModules(): Promise<RouteEntry[]> {
   const routes: RouteEntry[] = [];
 
-  // Skip the `index.ts` barrel: it re-exports every other route module's
-  // ROUTES into a single combined array, so importing it would double-count
-  // every entry. The duplicate `method:endpoint` keys are deduped later by
-  // first-seen, but the surviving entry's `sourceModule` (used to derive
-  // OpenAPI `tags`) depends on `readdir` order — which is filesystem
-  // dependent and diverges between local sandbox and the CI runner, making
-  // the generator non-reproducible. Sort the file list as well so directory
-  // entry order can never affect the output.
-  const files = (await readdir(ROUTES_DIR, { recursive: true }))
-    .filter(
-      (f) =>
-        typeof f === "string" &&
-        f.endsWith(".ts") &&
-        !f.endsWith(".test.ts") &&
-        !f.endsWith(".benchmark.test.ts") &&
-        !f.includes("node_modules") &&
-        f !== "index.ts" &&
-        !f.endsWith("/index.ts"),
-    )
-    .sort();
-
-  for (const file of files) {
-    const filePath = join(ROUTES_DIR, file);
-    let mod: Record<string, unknown>;
-    try {
-      mod = (await import(filePath)) as Record<string, unknown>;
-    } catch (err) {
-      console.warn(
-        `Warning: could not import ${file}: ${err instanceof Error ? err.message : err}`,
-      );
-      continue;
-    }
-
-    // Collect every export whose name is `ROUTES` or ends in `_ROUTES`.
-    // A handful of route files (e.g. `channel-route-definitions.ts`,
-    // `contact-prompt-routes.ts`) export under domain-prefixed names like
-    // `CHANNEL_ROUTES` and `CONTACT_PROMPT_ROUTES` rather than the
-    // canonical `ROUTES`. Without this fan-out the only way those routes
-    // reached the spec was via the `index.ts` barrel — which is excluded
-    // above for reproducibility.
-    const exportNames = Object.keys(mod)
-      .filter((k) => k === "ROUTES" || k.endsWith("_ROUTES"))
+  for (const dir of await routeModuleDirs()) {
+    // Skip the `index.ts` barrel: it re-exports every other route module's
+    // ROUTES into a single combined array, so importing it would double-count
+    // every entry. The duplicate `method:endpoint` keys are deduped later by
+    // first-seen, but the surviving entry's `sourceModule` (used to derive
+    // OpenAPI `tags`) depends on `readdir` order — which is filesystem
+    // dependent and diverges between local sandbox and the CI runner, making
+    // the generator non-reproducible. Sort the file list as well so directory
+    // entry order can never affect the output.
+    const files = (await readdir(dir, { recursive: true }))
+      .filter(
+        (f) =>
+          typeof f === "string" &&
+          f.endsWith(".ts") &&
+          !f.endsWith(".test.ts") &&
+          !f.endsWith(".benchmark.test.ts") &&
+          !f.includes("node_modules") &&
+          f !== "index.ts" &&
+          !f.endsWith("/index.ts"),
+      )
       .sort();
-    for (const name of exportNames) {
-      const arr = mod[name];
-      if (!Array.isArray(arr)) continue;
-      for (const raw of arr) {
-        const result = RouteEntrySchema.safeParse({
-          ...(typeof raw === "object" && raw !== null ? raw : {}),
-          sourceModule: file,
-        });
-        if (result.success) routes.push(result.data);
+
+    for (const file of files) {
+      const filePath = join(dir, file);
+      let mod: Record<string, unknown>;
+      try {
+        mod = (await import(filePath)) as Record<string, unknown>;
+      } catch (err) {
+        console.warn(
+          `Warning: could not import ${file}: ${err instanceof Error ? err.message : err}`,
+        );
+        continue;
+      }
+
+      // Collect every export whose name is `ROUTES` or ends in `_ROUTES`.
+      // A handful of route files (e.g. `channel-route-definitions.ts`,
+      // `contact-prompt-routes.ts`) export under domain-prefixed names like
+      // `CHANNEL_ROUTES` and `CONTACT_PROMPT_ROUTES` rather than the
+      // canonical `ROUTES`. Without this fan-out the only way those routes
+      // reached the spec was via the `index.ts` barrel — which is excluded
+      // above for reproducibility.
+      const exportNames = Object.keys(mod)
+        .filter((k) => k === "ROUTES" || k.endsWith("_ROUTES"))
+        .sort();
+      for (const name of exportNames) {
+        const arr = mod[name];
+        if (!Array.isArray(arr)) continue;
+        for (const raw of arr) {
+          const result = RouteEntrySchema.safeParse({
+            ...(typeof raw === "object" && raw !== null ? raw : {}),
+            sourceModule: file,
+          });
+          if (result.success) routes.push(result.data);
+        }
       }
     }
   }

package/src/__tests__/cli-memory-v2-reembed-skills.test.ts

@@ -54,7 +54,7 @@ mock.module("../memory/v2/skill-store.js", () => ({
 const { registerMemoryV2Command } =
   await import("../cli/commands/memory/memory-v2.js");
 const { ROUTES: memoryV2Routes, MEMORY_V2_DISABLED_CODE } =
-  await import("../runtime/routes/memory-v2-routes.js");
+  await import("../plugins/defaults/memory/routes/memory-v2-routes.js");
 const { RouteError } = await import("../runtime/routes/errors.js");
 
 // ---------------------------------------------------------------------------

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -91,15 +91,29 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../daemon/message-types/memory.js",
     "../../../../daemon/trust-context.js",
     "../../../../memory/graph/conversation-graph-memory.js",
+    "../../../../memory/graph/store.js",
+    "../../../../memory/graph/types.js",
     "../../../../memory/memory-marker.js",
     "../../../../memory/memory-recall-log-store.js",
+    "../../../../memory/memory-v2-concept-frequency.js",
     "../../../../memory/prompt-override.js",
     "../../../../memory/v2/cli-command-store.js",
+    "../../../../memory/v2/edge-index.js",
+    "../../../../memory/v2/harness/compare.js",
+    "../../../../memory/v2/harness/retriever.js",
+    "../../../../memory/v2/harness/router-retriever.js",
+    "../../../../memory/v2/harness/runner.js",
     "../../../../memory/v2/injected-block-slugs.js",
+    "../../../../memory/v2/injection-events.js",
+    "../../../../memory/v2/now-text.js",
     "../../../../memory/v2/page-index.js",
     "../../../../memory/v2/page-store.js",
+    "../../../../memory/v2/prompts/router.js",
+    "../../../../memory/v2/router.js",
     "../../../../memory/v2/sim.js",
     "../../../../memory/v2/skill-store.js",
+    "../../../../memory/v3-eval/eval-packets.js",
+    "../../../../memory/v3-eval/eval-tally.js",
     "../../../../persistence/checkpoints.js",
     "../../../../persistence/conversation-crud.js",
     "../../../../persistence/db-connection.js",
@@ -108,13 +122,18 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../persistence/embeddings/embedding-billing-breaker.js",
     "../../../../persistence/embeddings/embedding-cache.js",
     "../../../../persistence/embeddings/embedding-types.js",
+    "../../../../persistence/embeddings/qdrant-circuit-breaker.js",
     "../../../../persistence/embeddings/qdrant-client.js",
     "../../../../persistence/jobs-store.js",
     "../../../../persistence/message-content.js",
+    "../../../../persistence/schema/index.js",
     "../../../../providers/cache-control.js",
     "../../../../providers/provider-send-message.js",
     "../../../../providers/types.js",
     "../../../../runtime/assistant-event-hub.js",
+    "../../../../runtime/auth/route-policy.js",
+    "../../../../runtime/routes/errors.js",
+    "../../../../runtime/routes/types.js",
     "../../../../skills/frontmatter.js",
     "../../../../skills/install-meta.js",
     "../../../../tools/skills/delete-managed.js",
@@ -167,8 +186,10 @@ const BASELINE: Record<string, readonly string[]> = {
     "../injection-presence.js",
     "../injector-order.js",
     "@qdrant/js-client-rest",
+    "drizzle-orm",
     "node:crypto",
     "node:fs",
+    "node:fs/promises",
     "node:path",
     "uuid",
     "zod",

package/src/__tests__/workspace-migration-117-normalize-stale-lean-memory-v3-defaults.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Tests for workspace migration `117-normalize-stale-lean-memory-v3-defaults`.
+ *
+ * The first-launch seed persists the fully-defaulted config.json, so assistants
+ * created during the lean-default window stored the lean v3 tuning values as if
+ * explicit. The migration strips persisted v3 tuning leaves that equal the
+ * retired lean defaults so the restored full schema defaults re-apply, while
+ * preserving deliberate (non-lean) values, pre-lean full values, and untouched
+ * sibling fields. It never creates config.json and is idempotent.
+ */
+
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { MemoryV3ConfigSchema } from "../config/schemas/memory-v3.js";
+import { normalizeStaleLeanMemoryV3DefaultsMigration } from "../workspace/migrations/117-normalize-stale-lean-memory-v3-defaults.js";
+
+let workspaceDir: string;
+let configPath: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-117-test-"));
+  configPath = join(workspaceDir, "config.json");
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath, "utf-8"));
+}
+
+/** A config.json as the first-launch seed would persist it on the lean build:
+ *  the full v3 block with every tuning value at its lean default. */
+function leanSeedConfig(): Record<string, unknown> {
+  return {
+    memory: {
+      v3: {
+        live: true,
+        prune: { maxResidentBytes: 393216, targetResidentBytes: 262144 },
+        hotSet: { k: 8, halfLifeDays: 14 },
+        freshSet: { k: 8 },
+        learnedEdges: {
+          halfLifeDays: 30,
+          minCount: 3,
+          npmiFloor: 0.2,
+          maxPerPage: 6,
+          perSeed: 3,
+          cap: 0,
+        },
+        spotlight: { n: 6, windowTurns: 2 },
+        needleK: 12,
+        denseK: 0,
+        replyQueryK: 0,
+        selectorEnabled: false,
+        selectorPromptPath: null,
+        edge: { hubDegree: 30, seedCount: 6, perSeed: 1, cap: 6 },
+      },
+    },
+  };
+}
+
+describe("117-normalize-stale-lean-memory-v3-defaults migration", () => {
+  test("has correct id and description", () => {
+    expect(normalizeStaleLeanMemoryV3DefaultsMigration.id).toBe(
+      "117-normalize-stale-lean-memory-v3-defaults",
+    );
+    expect(normalizeStaleLeanMemoryV3DefaultsMigration.description).toContain(
+      "memory.v3",
+    );
+  });
+
+  test("strips lean tuning leaves so the full schema defaults re-apply", () => {
+    writeFileSync(configPath, JSON.stringify(leanSeedConfig()), "utf-8");
+
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+
+    const v3 = (readConfig().memory as Record<string, unknown>).v3 as Record<
+      string,
+      unknown
+    >;
+    // The switched leaves are gone…
+    expect("needleK" in v3).toBe(false);
+    expect("denseK" in v3).toBe(false);
+    expect("replyQueryK" in v3).toBe(false);
+    expect("selectorEnabled" in v3).toBe(false);
+    expect("k" in (v3.hotSet as Record<string, unknown>)).toBe(false);
+    expect("k" in (v3.freshSet as Record<string, unknown>)).toBe(false);
+    expect("cap" in (v3.learnedEdges as Record<string, unknown>)).toBe(false);
+    const edge = v3.edge as Record<string, unknown>;
+    expect("seedCount" in edge).toBe(false);
+    expect("perSeed" in edge).toBe(false);
+    expect("cap" in edge).toBe(false);
+
+    // …untouched siblings survive…
+    expect(v3.live).toBe(true);
+    expect((v3.hotSet as Record<string, unknown>).halfLifeDays).toBe(14);
+    expect(edge.hubDegree).toBe(30);
+    expect((v3.learnedEdges as Record<string, unknown>).perSeed).toBe(3);
+
+    // …and re-parsing yields the restored full profile.
+    const parsed = MemoryV3ConfigSchema.parse(v3);
+    expect(parsed.needleK).toBe(100);
+    expect(parsed.denseK).toBe(100);
+    expect(parsed.replyQueryK).toBe(12);
+    expect(parsed.selectorEnabled).toBe(true);
+    expect(parsed.hotSet.k).toBe(40);
+    expect(parsed.freshSet.k).toBe(100);
+    expect(parsed.learnedEdges.cap).toBe(20);
+    expect(parsed.edge).toEqual({
+      hubDegree: 30,
+      seedCount: 18,
+      perSeed: 6,
+      cap: 45,
+    });
+  });
+
+  test("leaves a config with any non-lean tuning untouched (not the lean-seed signature)", () => {
+    // A lean-seed config the user later edited one field of no longer matches
+    // the all-lean signature, so the migration leaves it alone rather than
+    // partially rewriting an explicit config.
+    const config = leanSeedConfig();
+    (
+      (config.memory as Record<string, unknown>).v3 as Record<string, unknown>
+    ).needleK = 50;
+    const original = JSON.stringify(config);
+    writeFileSync(configPath, original, "utf-8");
+
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe(original);
+  });
+
+  test("preserves a deliberate lean-valued override (partial config, not a full seed)", () => {
+    // An established assistant that deliberately disables dense retrieval must
+    // keep that choice — a lone lean-valued leaf is not the seed signature.
+    const original = JSON.stringify({ memory: { v3: { denseK: 0 } } });
+    writeFileSync(configPath, original, "utf-8");
+
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe(original);
+  });
+
+  test("leaves a pre-lean full config untouched (no write)", () => {
+    const fullConfig = {
+      memory: {
+        v3: {
+          needleK: 100,
+          denseK: 100,
+          replyQueryK: 12,
+          selectorEnabled: true,
+          hotSet: { k: 40, halfLifeDays: 14 },
+          freshSet: { k: 100 },
+          learnedEdges: { cap: 20, maxPerPage: 6 },
+          edge: { hubDegree: 30, seedCount: 18, perSeed: 6, cap: 45 },
+        },
+      },
+    };
+    const original = JSON.stringify(fullConfig);
+    writeFileSync(configPath, original, "utf-8");
+
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe(original);
+  });
+
+  test("no-op when config.json is absent (never creates it)", () => {
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+    expect(existsSync(configPath)).toBe(false);
+  });
+
+  test("no-op when there is no memory.v3 block", () => {
+    const original = JSON.stringify({ memory: { enabled: true } });
+    writeFileSync(configPath, original, "utf-8");
+
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe(original);
+  });
+
+  test("leaves malformed config.json untouched", () => {
+    writeFileSync(configPath, "{ not json", "utf-8");
+
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe("{ not json");
+  });
+
+  test("is idempotent", () => {
+    writeFileSync(configPath, JSON.stringify(leanSeedConfig()), "utf-8");
+
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+    const afterFirst = readFileSync(configPath, "utf-8");
+
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe(afterFirst);
+  });
+
+  test("down is a no-op", () => {
+    writeFileSync(configPath, JSON.stringify(leanSeedConfig()), "utf-8");
+    normalizeStaleLeanMemoryV3DefaultsMigration.run(workspaceDir);
+    const before = readFileSync(configPath, "utf-8");
+
+    normalizeStaleLeanMemoryV3DefaultsMigration.down(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe(before);
+  });
+});

package/src/cli/commands/memory/memory-v2.ts

@@ -27,7 +27,7 @@ import type {
   MemoryV2ReembedSkillsResult,
   MemoryV2SimulateRouterResult,
   MemoryV2ValidateResult,
-} from "../../../runtime/routes/memory-v2-routes.js";
+} from "../../../plugins/defaults/memory/routes/memory-v2-routes.js";
 import { registerCommand } from "../../lib/register-command.js";
 import { log } from "../../logger.js";
 import {

package/src/cli/commands/memory/memory-v3.ts

@@ -23,11 +23,11 @@ import { cliIpcCall } from "../../../ipc/cli-client.js";
 import type {
   MemoryEvalRunResult,
   MemoryEvalTallyResult,
-} from "../../../runtime/routes/memory-eval-routes.js";
+} from "../../../plugins/defaults/memory/routes/memory-eval-routes.js";
 import type {
   MemoryV3BackfillSectionsResult,
   MemoryV3RebuildIndexResult,
-} from "../../../runtime/routes/memory-v3-routes.js";
+} from "../../../plugins/defaults/memory/routes/memory-v3-routes.js";
 import { registerCommand } from "../../lib/register-command.js";
 import { log } from "../../logger.js";
 

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

@@ -8,23 +8,24 @@ describe("MemoryV3ConfigSchema", () => {
     expect(parsed).toEqual({
       live: false,
       prune: { maxResidentBytes: 393216, targetResidentBytes: 262144 },
-      hotSet: { k: 8, halfLifeDays: 14 },
-      freshSet: { k: 8 },
+      hotSet: { k: 40, halfLifeDays: 14 },
+      freshSet: { k: 100 },
       learnedEdges: {
         halfLifeDays: 30,
         minCount: 3,
         npmiFloor: 0.2,
         maxPerPage: 6,
         perSeed: 3,
-        cap: 0,
+        cap: 20,
       },
       spotlight: { n: 6, windowTurns: 2 },
-      needleK: 12,
-      denseK: 0,
-      replyQueryK: 0,
-      selectorEnabled: false,
+      needleK: 100,
+      denseK: 100,
+      replyQueryK: 12,
+      selectorEnabled: true,
       selectorPromptPath: null,
-      edge: { hubDegree: 30, seedCount: 6, perSeed: 1, cap: 6 },
+      edge: { hubDegree: 30, seedCount: 18, perSeed: 6, cap: 45 },
+      entity: { enabled: true, idfFloor: 4, cap: 8 },
     });
   });
 
@@ -105,9 +106,9 @@ describe("MemoryV3ConfigSchema", () => {
     const parsed = MemoryV3ConfigSchema.parse({ edge: { hubDegree: 10 } });
     expect(parsed.edge).toEqual({
       hubDegree: 10,
-      seedCount: 6,
-      perSeed: 1,
-      cap: 6,
+      seedCount: 18,
+      perSeed: 6,
+      cap: 45,
     });
   });