@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/memory/__tests__/memory-retrospective-startup-cleanup.test.ts

@@ -40,78 +40,81 @@ function isRetroSource(source: string | null): boolean {
   return source !== null && RETRO_SOURCES.includes(source);
 }
 
-mock.module("../db-connection.js", () => ({
-  getDb: () => ({
-    select: (cols?: Record<string, unknown>) => ({
-      from: (_table: { _: { name: string } } | unknown) => ({
-        where: (..._args: unknown[]) => ({
-          all: () => {
-            // Heuristic: tests only construct two query shapes — the jobs
-            // query and the conversations query. Distinguish by the first
-            // requested column shape.
-            const colKeys = cols ? Object.keys(cols) : [];
-            if (colKeys.includes("conversationId")) {
-              return mockJobs
-                .filter(
-                  (j) =>
-                    j.type === "memory_retrospective" &&
-                    (j.status === "pending" || j.status === "running"),
-                )
-                .map((j) => {
-                  let convId: string | null = null;
-                  try {
-                    const parsed = JSON.parse(j.payload) as {
-                      conversationId?: unknown;
-                    };
-                    if (typeof parsed.conversationId === "string") {
-                      convId = parsed.conversationId;
-                    }
-                  } catch {
-                    // Ignore malformed payload
+const makeFakeDb = () => ({
+  select: (cols?: Record<string, unknown>) => ({
+    from: (_table: { _: { name: string } } | unknown) => ({
+      where: (..._args: unknown[]) => ({
+        all: () => {
+          // Heuristic: tests only construct two query shapes — the jobs
+          // query and the conversations query. Distinguish by the first
+          // requested column shape.
+          const colKeys = cols ? Object.keys(cols) : [];
+          if (colKeys.includes("conversationId")) {
+            return mockJobs
+              .filter(
+                (j) =>
+                  j.type === "memory_retrospective" &&
+                  (j.status === "pending" || j.status === "running"),
+              )
+              .map((j) => {
+                let convId: string | null = null;
+                try {
+                  const parsed = JSON.parse(j.payload) as {
+                    conversationId?: unknown;
+                  };
+                  if (typeof parsed.conversationId === "string") {
+                    convId = parsed.conversationId;
                   }
-                  return { conversationId: convId };
-                });
-            }
-            // The "all retros" query (used to compute the preserved
-            // dedup-baseline per source) requests id + source +
-            // forkParentConversationId + createdAt with only the source +
-            // isNotNull(forkParent) predicate.
-            if (
-              colKeys.includes("forkParentConversationId") &&
-              colKeys.includes("createdAt")
-            ) {
-              return mockConversations
-                .filter((c) => isRetroSource(c.source))
-                .filter((c) => c.fork_parent_conversation_id !== null)
-                .map((c) => ({
-                  id: c.id,
-                  source: c.source,
-                  forkParentConversationId: c.fork_parent_conversation_id,
-                  createdAt: c.created_at,
-                }));
-            }
-            // Otherwise, this is the orphan-candidate query. The production
-            // predicate compares `forkParentConversationId` (the source ID
-            // encoded on the background conversation row) against the set
-            // of source IDs extracted from active jobs.
+                } catch {
+                  // Ignore malformed payload
+                }
+                return { conversationId: convId };
+              });
+          }
+          // The "all retros" query (used to compute the preserved
+          // dedup-baseline per source) requests id + source +
+          // forkParentConversationId + createdAt with only the source +
+          // isNotNull(forkParent) predicate.
+          if (
+            colKeys.includes("forkParentConversationId") &&
+            colKeys.includes("createdAt")
+          ) {
             return mockConversations
               .filter((c) => isRetroSource(c.source))
-              .filter(
-                (c) =>
-                  c.last_message_at !== null &&
-                  c.last_message_at < injectedNowMinusOrphanAgeMs,
-              )
-              .filter(
-                (c) =>
-                  c.fork_parent_conversation_id === null ||
-                  !activeJobSourceConvIds.has(c.fork_parent_conversation_id),
-              )
-              .map((c) => ({ id: c.id }));
-          },
-        }),
+              .filter((c) => c.fork_parent_conversation_id !== null)
+              .map((c) => ({
+                id: c.id,
+                source: c.source,
+                forkParentConversationId: c.fork_parent_conversation_id,
+                createdAt: c.created_at,
+              }));
+          }
+          // Otherwise, this is the orphan-candidate query. The production
+          // predicate compares `forkParentConversationId` (the source ID
+          // encoded on the background conversation row) against the set
+          // of source IDs extracted from active jobs.
+          return mockConversations
+            .filter((c) => isRetroSource(c.source))
+            .filter(
+              (c) =>
+                c.last_message_at !== null &&
+                c.last_message_at < injectedNowMinusOrphanAgeMs,
+            )
+            .filter(
+              (c) =>
+                c.fork_parent_conversation_id === null ||
+                !activeJobSourceConvIds.has(c.fork_parent_conversation_id),
+            )
+            .map((c) => ({ id: c.id }));
+        },
       }),
     }),
   }),
+});
+
+mock.module("../db-connection.js", () => ({
+  getDb: makeFakeDb,
+  getMemoryDb: makeFakeDb,
 }));
 
 let activeJobSourceConvIds = new Set<string>();

package/src/memory/__tests__/memory-retrospective-state.test.ts

@@ -33,7 +33,7 @@ import {
 } from "../memory-retrospective-state.js";
 import { memoryRetrospectiveState } from "../schema.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

package/src/memory/__tests__/memory-v2-activation-log-store.test.ts

@@ -32,7 +32,7 @@ import {
   sampleConfig,
 } from "./fixtures/memory-v2-activation-fixtures.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTables(): void {
   const db = getDb();

package/src/memory/__tests__/memory-v2-concept-frequency.test.ts

@@ -34,7 +34,7 @@ import { getConceptFrequencySummary } from "../memory-v2-concept-frequency.js";
 import { memoryV2ActivationLogs } from "../schema.js";
 import { sampleConfig } from "./fixtures/memory-v2-activation-fixtures.js";
 
-initializeDb();
+await initializeDb();
 
 const WORKSPACE = "/tmp/memory-v2-concept-frequency-test";
 

package/src/memory/__tests__/onboarding-events-store.test.ts

@@ -22,7 +22,7 @@ import {
 } from "../onboarding-events-store.js";
 import { onboardingEvents } from "../schema.js";
 
-initializeDb();
+await initializeDb();
 
 function resetTable(): void {
   getDb().delete(onboardingEvents).run();

package/src/memory/__tests__/prompt-override.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Tests for the shared prompt-override loader
+ * (`assistant/src/memory/prompt-override.ts`) and the memory-v3
+ * `resolveSelectorPrompt` built on it. Mirrors the v2 router/consolidation
+ * prompt-path suites: a configured file replaces the bundled prompt, and any
+ * missing / empty / oversized / non-regular / unreadable file degrades to the
+ * bundled prompt with a diagnostic warning.
+ */
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { resolveSelectorPrompt } from "../../plugins/defaults/memory-v3-shadow/pool-select.js";
+import {
+  loadPromptOverride,
+  MAX_PROMPT_OVERRIDE_BYTES,
+  resolveOverridePath,
+} from "../prompt-override.js";
+
+const warnCalls: Array<{ data: Record<string, unknown>; msg: string }> = [];
+const recordingLogger = {
+  warn: (data: object, msg: string) => {
+    warnCalls.push({ data: data as Record<string, unknown>, msg });
+  },
+};
+
+let tmpDir: string;
+
+beforeEach(() => {
+  warnCalls.length = 0;
+  tmpDir = mkdtempSync(join(tmpdir(), "prompt-override-"));
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+/** Load against the per-test temp dir with the recording logger. */
+const load = (
+  overridePath: string | null | undefined,
+  label = "test prompt",
+): string | null =>
+  loadPromptOverride({
+    overridePath,
+    workspaceDir: tmpDir,
+    log: recordingLogger,
+    label,
+  });
+
+describe("resolveOverridePath", () => {
+  test("expands a leading ~/ to the home directory", () => {
+    expect(resolveOverridePath("~/sub/x.md", tmpDir)).toBe(
+      join(homedir(), "sub/x.md"),
+    );
+  });
+
+  test("uses an absolute path as-is", () => {
+    expect(resolveOverridePath("/abs/x.md", tmpDir)).toBe("/abs/x.md");
+  });
+
+  test("resolves a relative path under the workspace dir", () => {
+    expect(resolveOverridePath("rel/x.md", tmpDir)).toBe(
+      join(tmpDir, "rel/x.md"),
+    );
+  });
+});
+
+describe("loadPromptOverride — usable override", () => {
+  test("null overridePath returns null without touching the filesystem", () => {
+    expect(load(null)).toBeNull();
+    expect(warnCalls).toHaveLength(0);
+  });
+
+  test("undefined overridePath (unset config field) returns null without throwing", () => {
+    expect(load(undefined)).toBeNull();
+    expect(warnCalls).toHaveLength(0);
+  });
+
+  test("returns an absolute-path file's contents verbatim", () => {
+    const p = join(tmpDir, "abs.md");
+    writeFileSync(p, "absolute body\n");
+    expect(load(p)).toBe("absolute body\n");
+    expect(warnCalls).toHaveLength(0);
+  });
+
+  test("resolves a relative path under the workspace dir", () => {
+    writeFileSync(join(tmpDir, "rel.md"), "relative body\n");
+    expect(load("rel.md")).toBe("relative body\n");
+    expect(warnCalls).toHaveLength(0);
+  });
+
+  test("expands a leading ~/ to the home directory", () => {
+    const filename = `.vellum-prompt-override-test-${process.pid}.md`;
+    const p = join(homedir(), filename);
+    writeFileSync(p, "home body\n");
+    try {
+      expect(load(`~/${filename}`)).toBe("home body\n");
+      expect(warnCalls).toHaveLength(0);
+    } finally {
+      rmSync(p, { force: true });
+    }
+  });
+});
+
+describe("loadPromptOverride — fallback to null with a diagnostic warning", () => {
+  test("missing file logs ENOENT and returns null", () => {
+    expect(load(join(tmpDir, "missing.md"))).toBeNull();
+    expect(warnCalls).toHaveLength(1);
+    expect(warnCalls[0].data.code).toBe("ENOENT");
+    expect(warnCalls[0].data.fallback).toBe("bundled");
+  });
+
+  test("empty file is rejected", () => {
+    const p = join(tmpDir, "empty.md");
+    writeFileSync(p, "");
+    expect(load(p)).toBeNull();
+    expect(warnCalls[0].data.reason).toBe("empty_override");
+  });
+
+  test("whitespace-only file is rejected", () => {
+    const p = join(tmpDir, "ws.md");
+    writeFileSync(p, "   \n\t\n");
+    expect(load(p)).toBeNull();
+    expect(warnCalls[0].data.reason).toBe("empty_override");
+  });
+
+  test("oversized file is rejected with its size", () => {
+    const p = join(tmpDir, "huge.md");
+    // 1 MiB + 1 byte — just over the cap so we don't waste test memory.
+    writeFileSync(p, Buffer.alloc(MAX_PROMPT_OVERRIDE_BYTES + 1, 0x61));
+    expect(load(p)).toBeNull();
+    expect(warnCalls[0].data.reason).toBe("oversized_override");
+    expect(warnCalls[0].data.size).toBe(MAX_PROMPT_OVERRIDE_BYTES + 1);
+  });
+
+  test("a directory is not a regular file", () => {
+    expect(load(tmpDir)).toBeNull();
+    expect(warnCalls[0].data.reason).toBe("not_regular_file");
+  });
+
+  test("a symlink is not a regular file (lstat does not follow it)", () => {
+    const target = join(tmpDir, "target.md");
+    writeFileSync(target, "real body\n");
+    const link = join(tmpDir, "link.md");
+    symlinkSync(target, link);
+    expect(load(link)).toBeNull();
+    expect(warnCalls[0].data.reason).toBe("not_regular_file");
+  });
+
+  test("a FIFO is not a regular file", () => {
+    const fifoPath = join(tmpDir, "fifo");
+    try {
+      execFileSync("mkfifo", [fifoPath]);
+    } catch {
+      // mkfifo unavailable on this platform — skip without failing.
+      return;
+    }
+    expect(load(fifoPath)).toBeNull();
+    expect(warnCalls[0].data.reason).toBe("not_regular_file");
+  });
+
+  test("the label names the prompt in the warning message", () => {
+    load(join(tmpDir, "missing.md"), "router prompt");
+    expect(warnCalls[0].msg).toContain("router prompt override");
+  });
+});
+
+describe("resolveSelectorPrompt", () => {
+  // A stable phrase from the bundled selector prompt (`SYSTEM_PROMPT`).
+  const BUNDLED_PHRASE =
+    "Select EVERY candidate whose content the upcoming reply would draw on";
+
+  test("null path returns the bundled selector prompt", () => {
+    expect(resolveSelectorPrompt(null, tmpDir)).toContain(BUNDLED_PHRASE);
+  });
+
+  test("a configured file replaces the bundled prompt verbatim — no placeholder substitution", () => {
+    const body = "Custom selector instructions {{NOT_A_PLACEHOLDER}}\n";
+    writeFileSync(join(tmpDir, "selector.md"), body);
+    const out = resolveSelectorPrompt("selector.md", tmpDir);
+    expect(out).toBe(body);
+    expect(out).not.toContain(BUNDLED_PHRASE);
+  });
+
+  test("a missing override falls back to the bundled prompt", () => {
+    expect(resolveSelectorPrompt(join(tmpDir, "nope.md"), tmpDir)).toContain(
+      BUNDLED_PHRASE,
+    );
+  });
+});

package/src/memory/__tests__/table-relocation.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Tests for the incremental table-relocation engine
+ * (`migrations/helpers/relocation.ts`), driven with migration 298's
+ * `MEMORY_JOBS_RELOCATION` spec.
+ *
+ * What this locks in:
+ *   1. `stageTableForRelocation` drops an empty source, renames a populated
+ *      one aside to `<table>__relocating`, and is idempotent across re-runs.
+ *   2. `drainStagedTable` copies the rows worth keeping into the target file,
+ *      purges the rest without copying, applies the spec's per-column
+ *      transforms (`running` → `pending`), and drops the staging table — so a
+ *      heavy table moves in bounded awaited batches rather than one blocking
+ *      shot.
+ *
+ * The drain runs through `runAsyncSqlite`, which targets the memory file
+ * directly (sqlite3 subprocess where available; in-process transient
+ * connection otherwise) — independent of the daemon connection, which no longer
+ * ATTACHes the dedicated files.
+ */
+import { describe, expect, test } from "bun:test";
+
+const { getSqlite, getMemorySqlite } = await import("../db-connection.js");
+const { initializeDb } = await import("../db-init.js");
+const { drainStagedTable, stageTableForRelocation } =
+  await import("../migrations/helpers/relocation.js");
+const { MEMORY_JOBS_RELOCATION } =
+  await import("../migrations/298-move-memory-jobs-to-memory-db.js");
+
+await initializeDb();
+
+function existsInMain(name: string): boolean {
+  return (
+    getSqlite()
+      .query(
+        `SELECT name FROM main.sqlite_master WHERE type='table' AND name = ?`,
+      )
+      .get(name) != null
+  );
+}
+
+const MEMORY_JOBS_COLUMNS = `
+  id TEXT PRIMARY KEY, type TEXT NOT NULL, payload TEXT NOT NULL,
+  status TEXT NOT NULL, attempts INTEGER NOT NULL DEFAULT 0,
+  deferrals INTEGER NOT NULL DEFAULT 0, run_after INTEGER NOT NULL,
+  last_error TEXT, started_at INTEGER,
+  created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL`;
+
+describe("stageTableForRelocation", () => {
+  test("drops an empty source and reports no drain needed", () => {
+    const sqlite = getSqlite();
+    sqlite.exec(`DROP TABLE IF EXISTS main.reloc_probe`);
+    sqlite.exec(`DROP TABLE IF EXISTS main."reloc_probe__relocating"`);
+    sqlite.exec(`CREATE TABLE main.reloc_probe (id INTEGER PRIMARY KEY)`);
+
+    expect(stageTableForRelocation(sqlite, "reloc_probe")).toBe(false);
+    expect(existsInMain("reloc_probe")).toBe(false);
+    expect(existsInMain("reloc_probe__relocating")).toBe(false);
+  });
+
+  test("renames a populated source aside, idempotently", () => {
+    const sqlite = getSqlite();
+    sqlite.exec(`DROP TABLE IF EXISTS main.reloc_probe`);
+    sqlite.exec(`DROP TABLE IF EXISTS main."reloc_probe__relocating"`);
+    sqlite.exec(`CREATE TABLE main.reloc_probe (id INTEGER PRIMARY KEY)`);
+    sqlite.exec(`INSERT INTO main.reloc_probe VALUES (1)`);
+
+    expect(stageTableForRelocation(sqlite, "reloc_probe")).toBe(true);
+    expect(existsInMain("reloc_probe")).toBe(false);
+    expect(existsInMain("reloc_probe__relocating")).toBe(true);
+
+    // Re-running with the staging table already present is a safe no-op.
+    expect(stageTableForRelocation(sqlite, "reloc_probe")).toBe(true);
+    const row = sqlite
+      .query<
+        { id: number },
+        []
+      >(`SELECT id FROM main."reloc_probe__relocating"`)
+      .get();
+    expect(row?.id).toBe(1);
+
+    sqlite.exec(`DROP TABLE IF EXISTS main."reloc_probe__relocating"`);
+  });
+});
+
+describe("memory_jobs drain", () => {
+  test("copies pending/running rows, purges terminal rows, drops staging", async () => {
+    const sqlite = getSqlite();
+    const memory = getMemorySqlite()!;
+
+    // Clean slate: empty live queue, fresh populated staging table.
+    memory.exec(`DELETE FROM memory_jobs`);
+    sqlite.exec(`DROP TABLE IF EXISTS main."memory_jobs__relocating"`);
+    sqlite.exec(
+      `CREATE TABLE main."memory_jobs__relocating" (${MEMORY_JOBS_COLUMNS})`,
+    );
+
+    const insert = sqlite.prepare(
+      `INSERT INTO main."memory_jobs__relocating"
+         (id, type, payload, status, run_after, created_at, updated_at)
+       VALUES (?, 'embed_segment', '{}', ?, 0, 0, 0)`,
+    );
+    insert.run("seed-keep-1", "pending");
+    insert.run("seed-keep-2", "pending");
+    insert.run("seed-keep-3", "running");
+    insert.run("seed-term-1", "completed");
+    insert.run("seed-term-2", "completed");
+    insert.run("seed-term-3", "failed");
+
+    await drainStagedTable(sqlite, MEMORY_JOBS_RELOCATION);
+
+    // Staging dropped.
+    expect(existsInMain("memory_jobs__relocating")).toBe(false);
+
+    // Exactly the three keepers landed in the memory database; the terminal
+    // rows were purged without being copied, and the in-flight `running` row
+    // was reset to `pending` so the worker can re-claim it in its new home.
+    const kept = memory
+      .query<
+        { id: string; status: string },
+        []
+      >(`SELECT id, status FROM memory_jobs WHERE id LIKE 'seed-%' ORDER BY id`)
+      .all();
+    expect(kept).toEqual([
+      { id: "seed-keep-1", status: "pending" },
+      { id: "seed-keep-2", status: "pending" },
+      { id: "seed-keep-3", status: "pending" },
+    ]);
+  });
+});