@vellumai/assistant 0.7.1 → 0.7.3

package/src/__tests__/memory-jobs-worker-lanes.test.ts

@@ -0,0 +1,188 @@
+/**
+ * Head-of-line repro for the per-lane scheduler in `runMemoryJobsOnce`.
+ *
+ * Before this fix, all non-embed jobs ran through a single bounded worker
+ * pool, so a long-running `graph_consolidate` LLM call would pin every slot
+ * and starve fast-lane jobs (e.g. `embed_concept_page` consolidation pages)
+ * for the duration of that call.
+ *
+ * The new scheduler runs slow / fast / embed lanes in parallel pools, each
+ * with its own concurrency budget. This test enqueues a wave of slow LLM
+ * jobs alongside fast jobs and asserts that every fast job completes before
+ * any slow job's promise resolves — proving the lanes are truly independent.
+ */
+import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import { DEFAULT_CONFIG } from "../config/defaults.js";
+import type { AssistantConfig } from "../config/types.js";
+
+// ── Mocks (must precede imports of tested module) ──────────────────
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Per-lane caps: 1 slow slot (so only 1 of the 5 enqueued slow jobs runs in
+// this tick) and a generous fast cap so every fast job both gets claimed
+// and gets a slot in the lane pool. The OLD shared-pool scheduler — which
+// claimed jobs without lane awareness and ran them through a single
+// workerConcurrency-sized pool — would pin its slots on the first claimed
+// slow jobs and force the fast jobs to queue behind a 200ms LLM call.
+const TEST_CONFIG: AssistantConfig = {
+  ...DEFAULT_CONFIG,
+  memory: {
+    ...DEFAULT_CONFIG.memory,
+    enabled: true,
+    jobs: {
+      ...DEFAULT_CONFIG.memory.jobs,
+      slowLlmConcurrency: 1,
+      fastConcurrency: 5,
+      embedConcurrency: 1,
+      workerConcurrency: 2,
+    },
+  },
+};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => TEST_CONFIG,
+  loadConfig: () => TEST_CONFIG,
+  invalidateConfigCache: () => {},
+}));
+
+// ── Track timestamps so we can assert ordering ─────────────────────
+
+type CompletionRecord = {
+  type: string;
+  conversationId: string;
+  completedAt: number;
+};
+const completions: CompletionRecord[] = [];
+
+// Slow-lane handler: blocks for SLOW_DELAY_MS. The test asserts every fast
+// job completes before any slow job — a single 200ms window is plenty.
+const SLOW_DELAY_MS = 200;
+
+mock.module("../memory/graph/consolidation.js", () => ({
+  runConsolidation: async (
+    scopeId: string,
+  ): Promise<{
+    totalUpdated: number;
+    totalDeleted: number;
+    totalMergeEdges: number;
+  }> => {
+    await new Promise((resolve) => setTimeout(resolve, SLOW_DELAY_MS));
+    completions.push({
+      type: "graph_consolidate",
+      conversationId: scopeId,
+      completedAt: Date.now(),
+    });
+    return { totalUpdated: 0, totalDeleted: 0, totalMergeEdges: 0 };
+  },
+}));
+
+// Fast-lane handler: resolves on the next microtask. The test fires this
+// many times in parallel; nothing should block.
+mock.module("../memory/jobs/embed-concept-page.js", () => ({
+  embedConceptPageJob: async (job: {
+    payload: { slug?: string };
+  }): Promise<void> => {
+    completions.push({
+      type: "embed_concept_page",
+      conversationId: job.payload.slug ?? "",
+      completedAt: Date.now(),
+    });
+  },
+}));
+
+// Stub remaining heavy boundaries that we never exercise but that get pulled
+// in transitively through jobs-worker's eager imports. These aren't strictly
+// required if the host machine can resolve them, but mocking them keeps the
+// test hermetic and fast under `bun test`.
+mock.module("../memory/db-maintenance.js", () => ({
+  maybeRunDbMaintenance: () => {},
+}));
+
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { enqueueMemoryJob } from "../memory/jobs-store.js";
+import { runMemoryJobsOnce } from "../memory/jobs-worker.js";
+import { _resetQdrantBreaker } from "../memory/qdrant-circuit-breaker.js";
+import { memoryJobs } from "../memory/schema.js";
+
+describe("memory jobs worker lane scheduling", () => {
+  beforeAll(() => {
+    initializeDb();
+  });
+
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM memory_jobs");
+    completions.length = 0;
+    _resetQdrantBreaker();
+  });
+
+  test("fast lane completes before slow lane releases its slot", async () => {
+    // 5 slow `graph_consolidate` jobs across distinct scopes (so they would
+    // serialize behind a single shared pool) plus 5 fast `embed_concept_page`
+    // jobs across distinct slugs.
+    for (let i = 0; i < 5; i++) {
+      enqueueMemoryJob("graph_consolidate", { scopeId: `slow-${i}` });
+    }
+    for (let i = 0; i < 5; i++) {
+      enqueueMemoryJob("embed_concept_page", { slug: `fast-${i}` });
+    }
+
+    await runMemoryJobsOnce();
+
+    const fastDone = completions.filter((c) => c.type === "embed_concept_page");
+    const slowDone = completions.filter((c) => c.type === "graph_consolidate");
+
+    // Slow lane is capped at 1 in this test, so only 1 slow job ran in this
+    // tick. Fast lane has cap 2, but with 5 fast jobs it runs all 5 because
+    // each handler resolves on the next microtask.
+    expect(fastDone).toHaveLength(5);
+    expect(slowDone).toHaveLength(1);
+
+    // Head-of-line guarantee: every fast completion timestamp must precede
+    // the (single) slow completion timestamp. Under the old shared pool with
+    // workerConcurrency=2 and 1 slow slot occupied, this still held only if
+    // a fast slot freed up first — but with 2 slow jobs in flight (the old
+    // claim path would have claimed multiple slow jobs into the shared pool)
+    // both slots would be pinned for SLOW_DELAY_MS and fast work would queue
+    // behind. With the lane scheduler, fast work has its own pool.
+    const earliestSlow = Math.min(...slowDone.map((c) => c.completedAt));
+    for (const fast of fastDone) {
+      expect(fast.completedAt).toBeLessThan(earliestSlow);
+    }
+
+    // Sanity: exactly 1 of the 5 enqueued slow jobs reached `completed` (the
+    // slow lane's per-tick budget). The other 4 are still pending and will be
+    // picked up on subsequent ticks. (FIFO ordering inside the slow lane is
+    // covered separately in jobs-store-qdrant-breaker.test.ts.)
+    //
+    // Note: a sixth `graph_consolidate` row may also appear here — the
+    // `maybeEnqueueGraphMaintenanceJobs` tail of `runMemoryJobsOnce` enqueues
+    // its own maintenance job whose checkpoint is missing in this fresh DB.
+    // That row is irrelevant; we only care about the completed-vs-pending
+    // counts of jobs we explicitly seeded.
+    const completedSlow = countSlowByStatus("completed");
+    expect(completedSlow).toBe(1);
+  });
+});
+
+function countSlowByStatus(
+  status: "pending" | "running" | "completed",
+): number {
+  const db = getDb();
+  return db
+    .select()
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, "graph_consolidate"))
+    .all()
+    .filter((row) => row.status === status).length;
+}

package/src/__tests__/memory-retrieval-pipeline.test.ts

@@ -158,6 +158,27 @@ describe("runDefaultMemoryRetrieval", () => {
     expect(result.nowContent).toBe("now-default");
   });
 
+  test("propagates errors from prepareMemory rather than swallowing them", async () => {
+    // Memory is critical — failures must surface to the caller (the agent
+    // loop) rather than silently degrading to an empty memory block.
+    const failingPrepare = mock(
+      (
+        _msgs: Message[],
+        _cfg: AssistantConfig,
+        _signal: AbortSignal,
+        _onEvent: (msg: ServerMessage) => void,
+      ) => Promise.reject(new Error("retrieval failed")),
+    );
+    const graphMemory = {
+      prepareMemory: failingPrepare,
+    } as unknown as ConversationGraphMemory;
+    const deps = makeDeps({ graphMemory, isTrustedActor: true });
+
+    await expect(
+      runDefaultMemoryRetrieval(makeMemoryArgs(), deps),
+    ).rejects.toThrow("retrieval failed");
+  });
+
   test("passes through null PKB and NOW when the files are absent", async () => {
     readPkbContextMock.mockImplementation(() => null);
     readNowContextMock.mockImplementation(() => null);
@@ -314,7 +335,7 @@ describe("memoryRetrieval pipeline — default vs custom plugin", () => {
         (innerArgs: MemoryArgs) => runDefaultMemoryRetrieval(innerArgs, deps),
         args,
         makeTurnCtx(),
-        30, // tiny budget — real production path uses 5_000ms
+        30, // tiny pipeline budget to keep the test fast
       );
     } catch (err) {
       caught = err;

package/src/__tests__/migration-import-commit-http.test.ts

@@ -256,6 +256,8 @@ function createValidVBundle(
     bundle_id: string;
     origin_mode: "managed" | "self-hosted-remote" | "self-hosted-local";
     secrets_redacted: boolean;
+    min_runtime_version: string;
+    max_runtime_version: string | null;
   }>,
 ): Uint8Array {
   const dbData = new Uint8Array([0x53, 0x51, 0x4c, 0x69, 0x74, 0x65]);
@@ -296,8 +298,11 @@ function createValidVBundle(
       mode: overrides?.origin_mode ?? "self-hosted-local",
     },
     compatibility: {
-      min_runtime_version: "0.0.0-test",
-      max_runtime_version: null,
+      min_runtime_version: overrides?.min_runtime_version ?? "0.0.0-test",
+      max_runtime_version:
+        overrides?.max_runtime_version === undefined
+          ? null
+          : overrides.max_runtime_version,
     },
     contents,
     checksum: "",
@@ -652,6 +657,107 @@ describe("handleMigrationImport — validation failures", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// HTTP handler tests: version_incompatible (Codex P2 regression)
+//
+// Pin: a bundle whose min_runtime_version exceeds APP_VERSION must surface as
+// a 4xx user-actionable response (422 Unprocessable Entity), not a 500
+// InternalError. Body mirrors the platform's PR #5470 response shape so
+// clients can render the same UX regardless of which gate (platform or
+// runtime) rejected the bundle.
+// ---------------------------------------------------------------------------
+
+describe("handleMigrationImport — version_incompatible", () => {
+  test("incompatible bundle returns 422 with structured body, not 500", async () => {
+    const vbundle = createValidVBundle(undefined, {
+      min_runtime_version: "99.0.0",
+    });
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/octet-stream" },
+      body: toArrayBuffer(vbundle),
+    });
+
+    const res = await callHandler(handleMigrationImport, req);
+    const body = (await res.json()) as {
+      error: {
+        code: string;
+        message: string;
+        details?: {
+          reason: string;
+          bundle_compat: {
+            min_runtime_version: string;
+            max_runtime_version: string | null;
+          };
+          runtime_version: string;
+        };
+      };
+    };
+
+    expect(res.status).toBe(422);
+    expect(body.error.code).toBe("UNPROCESSABLE_ENTITY");
+    expect(body.error.message).toContain("99.0.0");
+    expect(body.error.details).toBeDefined();
+    expect(body.error.details!.reason).toBe("version_incompatible");
+    expect(body.error.details!.bundle_compat.min_runtime_version).toBe(
+      "99.0.0",
+    );
+    expect(body.error.details!.bundle_compat.max_runtime_version).toBeNull();
+    expect(typeof body.error.details!.runtime_version).toBe("string");
+  });
+
+  test("incompatible bundle does not modify disk", async () => {
+    const originalDb = new Uint8Array(readFileSync(testDbPath));
+    const originalConfig = readFileSync(testConfigPath, "utf8");
+
+    const vbundle = createValidVBundle(undefined, {
+      min_runtime_version: "99.0.0",
+    });
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/octet-stream" },
+      body: toArrayBuffer(vbundle),
+    });
+
+    await callHandler(handleMigrationImport, req);
+
+    const currentDb = new Uint8Array(readFileSync(testDbPath));
+    const currentConfig = readFileSync(testConfigPath, "utf8");
+
+    expect(currentDb).toEqual(originalDb);
+    expect(currentConfig).toBe(originalConfig);
+  });
+
+  // Regression: the route handler pre-checks runtime-version compat using
+  // `validation.manifest.compatibility` before calling `resetDb()` and
+  // `commitImport()`. If a future refactor reorders the close to come
+  // before the gate, an incompatible bundle would still 422 (commitImport
+  // has its own defense-in-depth gate) but it would unnecessarily close
+  // and reopen the live SQLite singleton on every rejected import.
+  //
+  // We can't easily spy on `resetDb` here without mocking `db-connection.js`
+  // module-wide (which other tests in this file rely on for real). The
+  // semantic regression — disk unchanged + 422 — is covered by the two
+  // tests above. This test is a marker so future readers know the pre-
+  // check intent; if it ever starts failing, recheck `handleMigrationImport`
+  // ordering against the comment at line 861-862 ("Validate the bundle
+  // before closing the DB to avoid an unnecessary close/reopen cycle when
+  // the bundle is invalid").
+  test("incompatible bundle short-circuits before resetDb (intent marker)", async () => {
+    const vbundle = createValidVBundle(undefined, {
+      min_runtime_version: "99.0.0",
+    });
+    const req = new Request("http://localhost/v1/migrations/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/octet-stream" },
+      body: toArrayBuffer(vbundle),
+    });
+
+    const res = await callHandler(handleMigrationImport, req);
+    expect(res.status).toBe(422);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // commitImport unit tests
 // ---------------------------------------------------------------------------

package/src/__tests__/mock-gateway-ipc.ts

@@ -38,6 +38,7 @@ import { mock } from "bun:test";
 // ---------------------------------------------------------------------------
 
 /** IPC result the fake gateway will return (keyed by method name). */
+
 let ipcResults: Record<string, unknown> = {};
 
 /** Whether the fake ipcCall should simulate a connection error. */

package/src/__tests__/normalize-onboarding.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  normalizeOnboardingContext,
+  normalizeTasks,
+  normalizeTools,
+  TASK_DISPLAY_LABELS,
+  TOOL_DISPLAY_NAMES,
+} from "../prompts/normalize-onboarding.js";
+import type { OnboardingContext } from "../types/onboarding-context.js";
+
+describe("normalizeTools", () => {
+  test("known tool IDs produce display labels", () => {
+    expect(normalizeTools(["github"])).toEqual(["GitHub"]);
+    expect(normalizeTools(["google-calendar"])).toEqual(["Google Calendar"]);
+    expect(normalizeTools(["slack"])).toEqual(["Slack"]);
+    expect(normalizeTools(["notion"])).toEqual(["Notion"]);
+    expect(normalizeTools(["linear"])).toEqual(["Linear"]);
+    expect(normalizeTools(["gmail"])).toEqual(["Gmail"]);
+    expect(normalizeTools(["google-drive"])).toEqual(["Google Drive"]);
+    expect(normalizeTools(["figma"])).toEqual(["Figma"]);
+    expect(normalizeTools(["jira"])).toEqual(["Jira"]);
+    expect(normalizeTools(["outlook"])).toEqual(["Outlook"]);
+    expect(normalizeTools(["excel"])).toEqual(["Excel"]);
+    expect(normalizeTools(["apple-notes"])).toEqual(["Apple Notes"]);
+  });
+
+  test("all known tool IDs from the client onboarding UI are mapped", () => {
+    const clientToolIds = [
+      "gmail",
+      "outlook",
+      "google-calendar",
+      "slack",
+      "notion",
+      "linear",
+      "jira",
+      "github",
+      "figma",
+      "google-drive",
+      "excel",
+      "apple-notes",
+    ];
+    expect(Object.keys(TOOL_DISPLAY_NAMES)).toEqual(
+      expect.arrayContaining(clientToolIds),
+    );
+    expect(Object.keys(TOOL_DISPLAY_NAMES)).toHaveLength(clientToolIds.length);
+  });
+
+  test("unknown/custom tool IDs pass through with first-letter capitalization", () => {
+    expect(normalizeTools(["trello"])).toEqual(["Trello"]);
+    expect(normalizeTools(["asana"])).toEqual(["Asana"]);
+  });
+
+  test("mixed known and unknown IDs normalize correctly", () => {
+    expect(normalizeTools(["github", "trello", "slack"])).toEqual([
+      "GitHub",
+      "Trello",
+      "Slack",
+    ]);
+  });
+
+  test("empty array produces empty array", () => {
+    expect(normalizeTools([])).toEqual([]);
+  });
+});
+
+describe("normalizeTasks", () => {
+  test("known task IDs produce plain-language labels", () => {
+    expect(normalizeTasks(["code-building"])).toEqual([
+      "builds code, apps, or tools",
+    ]);
+    expect(normalizeTasks(["writing"])).toEqual([
+      "writes docs, emails, or content",
+    ]);
+    expect(normalizeTasks(["research"])).toEqual([
+      "does research and analysis",
+    ]);
+    expect(normalizeTasks(["project-management"])).toEqual([
+      "plans and coordinates work",
+    ]);
+    expect(normalizeTasks(["scheduling"])).toEqual([
+      "handles meetings, calendar, and logistics",
+    ]);
+    expect(normalizeTasks(["personal"])).toEqual(["handles life admin"]);
+  });
+
+  test("all six known task IDs are mapped", () => {
+    const knownIds = [
+      "code-building",
+      "writing",
+      "research",
+      "project-management",
+      "scheduling",
+      "personal",
+    ];
+    expect(Object.keys(TASK_DISPLAY_LABELS)).toEqual(
+      expect.arrayContaining(knownIds),
+    );
+    expect(Object.keys(TASK_DISPLAY_LABELS)).toHaveLength(knownIds.length);
+  });
+
+  test("unknown/custom task IDs pass through unchanged", () => {
+    expect(normalizeTasks(["data-entry"])).toEqual(["data-entry"]);
+    expect(normalizeTasks(["custom-workflow"])).toEqual(["custom-workflow"]);
+  });
+
+  test("mixed known and unknown IDs normalize correctly", () => {
+    expect(normalizeTasks(["writing", "data-entry", "research"])).toEqual([
+      "writes docs, emails, or content",
+      "data-entry",
+      "does research and analysis",
+    ]);
+  });
+
+  test("empty array produces empty array", () => {
+    expect(normalizeTasks([])).toEqual([]);
+  });
+});
+
+describe("normalizeOnboardingContext", () => {
+  test("maps userName to preferredName", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "friendly",
+      userName: "Alice",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.preferredName).toBe("Alice");
+  });
+
+  test("absent userName yields undefined preferredName", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "professional",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.preferredName).toBeUndefined();
+  });
+
+  test("tone passes through", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "casual",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.tone).toBe("casual");
+  });
+
+  test("assistantName passes through", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "friendly",
+      assistantName: "Jarvis",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.assistantName).toBe("Jarvis");
+  });
+
+  test("normalizes tools and tasks together", () => {
+    const ctx: OnboardingContext = {
+      tools: ["github", "trello"],
+      tasks: ["code-building", "data-entry"],
+      tone: "professional",
+      userName: "Bob",
+      assistantName: "Friday",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result).toEqual({
+      preferredName: "Bob",
+      commonWork: ["builds code, apps, or tools", "data-entry"],
+      dailyTools: ["GitHub", "Trello"],
+      tone: "professional",
+      assistantName: "Friday",
+    });
+  });
+});

package/src/__tests__/oauth-cli.test.ts

@@ -380,12 +380,10 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockGetConfig(),
   getConfigReadOnly: () => mockGetConfig(),
   loadConfig: () => mockGetConfig(),
-  saveConfig: () => {},
   invalidateConfigCache: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   applyNestedDefaults: (c: unknown) => c,
-  deepMergeMissing: (a: unknown) => a,
   deepMergeOverwrite: (a: unknown) => a,
   mergeDefaultWorkspaceConfig: () => {},
   getNestedValue: () => undefined,