@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

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

@@ -1,192 +0,0 @@
-/**
- * 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__/watchdog-events-store.test.ts

@@ -1,161 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// Silence the logger.
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-let shareAnalytics = true;
-
-mock.module("../../platform/consent-cache.js", () => ({
-  getCachedShareAnalytics: () => shareAnalytics,
-}));
-
-import { getTelemetryDb } from "../db-connection.js";
-import { initializeDb } from "../db-init.js";
-import { watchdogEvents } from "../schema.js";
-import {
-  queryUnreportedWatchdogEvents,
-  recordWatchdogEvent,
-} from "../watchdog-events-store.js";
-
-await initializeDb();
-
-function insertEvent(
-  id: string,
-  createdAt: number,
-  checkName = "event_loop_blocked",
-): void {
-  const db = getTelemetryDb();
-  if (!db) throw new Error("telemetry DB unavailable in test");
-  db.insert(watchdogEvents).values({ id, createdAt, checkName }).run();
-}
-
-function clearEvents(): void {
-  const db = getTelemetryDb();
-  if (!db) throw new Error("telemetry DB unavailable in test");
-  db.delete(watchdogEvents).run();
-}
-
-describe("watchdog-events-store", () => {
-  beforeEach(() => {
-    shareAnalytics = true;
-    clearEvents();
-  });
-
-  test("honors the share_analytics opt-out (records nothing)", () => {
-    shareAnalytics = false;
-    recordWatchdogEvent({ checkName: "event_loop_blocked", value: 60000 });
-    expect(queryUnreportedWatchdogEvents(0, undefined, 10)).toHaveLength(0);
-  });
-
-  test("record + query round-trips all fields", () => {
-    recordWatchdogEvent({
-      checkName: "event_loop_blocked",
-      value: 12345,
-      detail: { reason: "no_bytes_60s", threshold_ms: 5000 },
-    });
-
-    const rows = queryUnreportedWatchdogEvents(0, undefined, 10);
-    expect(rows).toHaveLength(1);
-    const row = rows[0]!;
-    expect(row.id).toBeString();
-    expect(row.createdAt).toBeGreaterThan(0);
-    expect(row.checkName).toBe("event_loop_blocked");
-    expect(row.value).toBe(12345);
-    expect(row.detail).toBe(
-      JSON.stringify({ reason: "no_bytes_60s", threshold_ms: 5000 }),
-    );
-  });
-
-  test("optional fields persist as null", () => {
-    recordWatchdogEvent({ checkName: "stream_idle" });
-
-    const rows = queryUnreportedWatchdogEvents(0, undefined, 10);
-    expect(rows).toHaveLength(1);
-    expect(rows[0]).toMatchObject({
-      checkName: "stream_idle",
-      value: null,
-      detail: null,
-    });
-  });
-
-  test("explicit null value and detail persist as null", () => {
-    recordWatchdogEvent({
-      checkName: "restart",
-      value: null,
-      detail: null,
-    });
-
-    const rows = queryUnreportedWatchdogEvents(0, undefined, 10);
-    expect(rows).toHaveLength(1);
-    expect(rows[0]?.value).toBeNull();
-    expect(rows[0]?.detail).toBeNull();
-  });
-
-  test("returns rows in (createdAt, id) order", () => {
-    insertEvent("wd-b", 2000);
-    insertEvent("wd-a", 1000);
-
-    const rows = queryUnreportedWatchdogEvents(0, undefined, 100);
-    expect(rows.map((r) => r.id)).toEqual(["wd-a", "wd-b"]);
-  });
-
-  test("query advances past the compound (createdAt, id) cursor", () => {
-    // Two rows in the same millisecond: pagination must use the id
-    // tiebreaker to make forward progress, not loop.
-    insertEvent("wd-1", 5000);
-    insertEvent("wd-2", 5000);
-    insertEvent("wd-3", 6000);
-
-    const first = queryUnreportedWatchdogEvents(0, undefined, 1);
-    expect(first.map((r) => r.id)).toEqual(["wd-1"]);
-
-    const second = queryUnreportedWatchdogEvents(
-      first[0]!.createdAt,
-      first[0]!.id,
-      100,
-    );
-    expect(second.map((r) => r.id)).toEqual(["wd-2", "wd-3"]);
-
-    // Without an id cursor the timestamp-only branch is used.
-    expect(
-      queryUnreportedWatchdogEvents(5000, undefined, 100).map((r) => r.id),
-    ).toEqual(["wd-3"]);
-
-    // Cursor past the last row returns nothing.
-    const last = second[second.length - 1]!;
-    expect(
-      queryUnreportedWatchdogEvents(last.createdAt, last.id, 100).length,
-    ).toBe(0);
-  });
-
-  test("resumes from a persisted watermark without re-reporting", () => {
-    insertEvent("wd-w1", 1000);
-    insertEvent("wd-w2", 2000);
-
-    const batch = queryUnreportedWatchdogEvents(0, undefined, 100);
-    const watermark = batch[batch.length - 1]!;
-
-    insertEvent("wd-w3", 3000);
-
-    const resumed = queryUnreportedWatchdogEvents(
-      watermark.createdAt,
-      watermark.id,
-      100,
-    );
-    expect(resumed.map((r) => r.id)).toEqual(["wd-w3"]);
-  });
-
-  test("honors the limit", () => {
-    insertEvent("wd-l1", 1000);
-    insertEvent("wd-l2", 2000);
-    insertEvent("wd-l3", 3000);
-
-    const rows = queryUnreportedWatchdogEvents(0, undefined, 2);
-    expect(rows.map((r) => r.id)).toEqual(["wd-l1", "wd-l2"]);
-  });
-});

package/src/memory/migrations/300-add-processing-started-at.ts

@@ -1,30 +0,0 @@
-import type { DrizzleDb } from "../db-connection.js";
-import { tableHasColumn } from "./schema-introspection.js";
-
-const COLUMN_NAME = "processing_started_at";
-const COLUMN_DEFINITION = "processing_started_at INTEGER";
-
-/**
- * Add `processing_started_at` column to the `conversations` table.
- *
- * The column is a nullable epoch-ms timestamp: non-NULL means the agent loop
- * is mid-turn for this conversation, NULL means idle. This is the
- * cross-process source of truth for processing state — the in-memory
- * `Conversation._processing` flag is the hot-path read for resident
- * conversations, but out-of-process callers (e.g. the retrospective CLI)
- * read this column directly via `isConversationProcessing()`.
- *
- * No backfill is needed — all existing rows default to NULL (not processing),
- * which is correct for any conversation that isn't actively mid-turn at
- * migration time.
- *
- * Idempotent: guarded with `tableHasColumn` so a crash between the `ALTER
- * TABLE` and the checkpoint write doesn't cause a duplicate-column error on
- * the next boot.
- */
-export function migrateAddProcessingStartedAt(database: DrizzleDb): void {
-  if (tableHasColumn(database, "conversations", COLUMN_NAME)) {
-    return;
-  }
-  database.run(`ALTER TABLE conversations ADD COLUMN ${COLUMN_DEFINITION}`);
-}

package/src/memory/migrations/301-create-watchdog-events.ts

@@ -1,45 +0,0 @@
-import { Database } from "bun:sqlite";
-
-import { getTelemetryDbPath } from "../../util/telemetry-db-path.js";
-import {
-  type DrizzleDb,
-  getTelemetrySqlite,
-} from "../db-connection.js";
-
-/**
- * Create the `watchdog_events` table on the dedicated telemetry database
- * (`assistant-telemetry.db`), not the main DB. The migration runner passes the
- * main DrizzleDb, but this table lives on the telemetry connection, so we open
- * that connection and run DDL against it directly. The dedicated connection
- * itself performs no DDL on open, so this migration owns the schema.
- *
- * Idempotent (`IF NOT EXISTS`). Writes are gated on `share_analytics`
- * consent at the store level, so opted-out rows never exist and the
- * reporter's standard 0 watermark default is safe. The index backs the
- * telemetry reporter's compound `(created_at, id)` watermark cursor.
- *
- * The `mainDb` parameter is accepted to satisfy the migration-step signature but
- * is not used — this migration operates exclusively on the telemetry DB.
- */
-export function createWatchdogEventsTable(_mainDb: DrizzleDb): void {
-  let raw: Database | null = getTelemetrySqlite();
-  if (!raw) {
-    // The dedicated connection failed to open (logged by openDedicatedDb).
-    // Fall back to opening the file directly so the migration still runs —
-    // the singleton will pick it up on a later access. This mirrors the
-    // fail-soft pattern of the other dedicated-DB migrations.
-    raw = new Database(getTelemetryDbPath());
-  }
-  raw.exec(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS watchdog_events (
-      id TEXT PRIMARY KEY,
-      created_at INTEGER NOT NULL,
-      check_name TEXT NOT NULL,
-      value REAL,
-      detail TEXT
-    )
-  `);
-  raw.exec(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_watchdog_events_created_at_id ON watchdog_events (created_at, id)`,
-  );
-}

package/src/memory/migrations/__tests__/209-strip-thinking-from-consolidated.test.ts

@@ -1,224 +0,0 @@
-/**
- * Tests for migration 209 — stripping thinking / redacted_thinking blocks from
- * persisted assistant messages.
- *
- * The migration rewrites content entirely inside SQLite (JSON1), dispatched a
- * rowid window at a time through `runAsyncSqlite`. These tests drive the step
- * directly against a real DB and assert the at-rest content, idempotency,
- * scoping (assistant rows only), tolerance of malformed content, and that the
- * persisted rowid watermark is honored for resume.
- */
-import { describe, expect, test } from "bun:test";
-
-const { getDb, getSqlite } = await import("../../db-connection.js");
-const { initializeDb } = await import("../../db-init.js");
-const { migrateStripThinkingFromConsolidated } =
-  await import("../209-strip-thinking-from-consolidated.js");
-
-await initializeDb();
-
-const CONV = "conv-209";
-getSqlite()
-  .query(
-    `INSERT OR IGNORE INTO conversations (id, created_at, updated_at) VALUES (?, ?, ?)`,
-  )
-  .run(CONV, Date.now(), Date.now());
-
-let seq = 0;
-function insert(role: string, content: string): { id: string; rowid: number } {
-  const id = `m209-${seq++}`;
-  getSqlite()
-    .query(
-      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)`,
-    )
-    .run(id, CONV, role, content, Date.now());
-  const rowid = (
-    getSqlite()
-      .query(`SELECT rowid AS r FROM messages WHERE id = ?`)
-      .get(id) as { r: number }
-  ).r;
-  return { id, rowid };
-}
-
-function content(id: string): string {
-  return (
-    getSqlite().query(`SELECT content FROM messages WHERE id = ?`).get(id) as {
-      content: string;
-    }
-  ).content;
-}
-
-function blocks(id: string): Array<Record<string, unknown>> {
-  return JSON.parse(content(id));
-}
-
-describe("migration 209 — strip thinking from consolidated assistant messages", () => {
-  test("strips thinking blocks but keeps text and tool_use, preserving order", async () => {
-    const { id } = insert(
-      "assistant",
-      JSON.stringify([
-        { type: "thinking", thinking: "secret", signature: "sig" },
-        { type: "text", text: "hello" },
-        { type: "tool_use", id: "t1", name: "x", input: { a: 1 } },
-      ]),
-    );
-
-    await migrateStripThinkingFromConsolidated(getDb());
-
-    expect(blocks(id)).toEqual([
-      { type: "text", text: "hello" },
-      { type: "tool_use", id: "t1", name: "x", input: { a: 1 } },
-    ]);
-  });
-
-  test("strips redacted_thinking blocks", async () => {
-    const { id } = insert(
-      "assistant",
-      JSON.stringify([
-        { type: "redacted_thinking", data: "blob" },
-        { type: "text", text: "world" },
-      ]),
-    );
-
-    await migrateStripThinkingFromConsolidated(getDb());
-
-    expect(blocks(id)).toEqual([{ type: "text", text: "world" }]);
-  });
-
-  test("all-thinking message becomes the null-byte placeholder sentinel", async () => {
-    const { id } = insert(
-      "assistant",
-      JSON.stringify([
-        { type: "thinking", thinking: "a", signature: "s1" },
-        { type: "redacted_thinking", data: "b" },
-      ]),
-    );
-
-    await migrateStripThinkingFromConsolidated(getDb());
-
-    const result = blocks(id);
-    expect(result).toHaveLength(1);
-    expect(result[0].type).toBe("text");
-    expect(result[0].text).toBe("\x00__PLACEHOLDER__[internal blocks omitted]");
-    // The leading byte must be a literal NUL, produced by SQLite's char(0).
-    expect((result[0].text as string).charCodeAt(0)).toBe(0);
-  });
-
-  test("preserves blocks with a missing/null type", async () => {
-    const { id } = insert(
-      "assistant",
-      JSON.stringify([
-        { type: "thinking", thinking: "x", signature: "s" },
-        { foo: "bar" },
-        { type: "text", text: "kept" },
-      ]),
-    );
-
-    await migrateStripThinkingFromConsolidated(getDb());
-
-    expect(blocks(id)).toEqual([
-      { foo: "bar" },
-      { type: "text", text: "kept" },
-    ]);
-  });
-
-  test("leaves thinking-free assistant messages untouched", async () => {
-    const original = JSON.stringify([
-      { type: "text", text: "I was thinking about lunch" },
-    ]);
-    const { id } = insert("assistant", original);
-
-    await migrateStripThinkingFromConsolidated(getDb());
-
-    // Substring 'thinking' appears in the text but no block is of thinking type.
-    expect(content(id)).toBe(original);
-  });
-
-  test("does not touch non-assistant roles", async () => {
-    const original = JSON.stringify([
-      { type: "thinking", thinking: "x", signature: "s" },
-      { type: "text", text: "u" },
-    ]);
-    const { id } = insert("user", original);
-
-    await migrateStripThinkingFromConsolidated(getDb());
-
-    expect(content(id)).toBe(original);
-  });
-
-  test("tolerates non-array and invalid JSON content", async () => {
-    const obj = insert(
-      "assistant",
-      JSON.stringify({ type: "thinking", thinking: "x" }),
-    );
-    const invalid = insert("assistant", "{not json with thinking");
-
-    await migrateStripThinkingFromConsolidated(getDb());
-
-    expect(content(obj.id)).toBe(
-      JSON.stringify({ type: "thinking", thinking: "x" }),
-    );
-    expect(content(invalid.id)).toBe("{not json with thinking");
-  });
-
-  test("is idempotent across repeated runs", async () => {
-    const { id } = insert(
-      "assistant",
-      JSON.stringify([
-        { type: "thinking", thinking: "x", signature: "s" },
-        { type: "text", text: "stable" },
-      ]),
-    );
-
-    await migrateStripThinkingFromConsolidated(getDb());
-    const once = content(id);
-    await migrateStripThinkingFromConsolidated(getDb());
-    const twice = content(id);
-
-    expect(twice).toBe(once);
-    expect(blocks(id)).toEqual([{ type: "text", text: "stable" }]);
-  });
-
-  test("honors the persisted rowid watermark and resumes above it", async () => {
-    const below = insert(
-      "assistant",
-      JSON.stringify([
-        { type: "thinking", thinking: "x", signature: "s" },
-        { type: "text", text: "below" },
-      ]),
-    );
-    const above = insert(
-      "assistant",
-      JSON.stringify([
-        { type: "thinking", thinking: "y", signature: "s" },
-        { type: "text", text: "above" },
-      ]),
-    );
-
-    // Pretend a prior run already swept through `below`'s rowid: the sweep must
-    // resume strictly above it, leaving `below` untouched and cleaning `above`.
-    getSqlite()
-      .query(
-        `INSERT OR REPLACE INTO memory_checkpoints (key, value, updated_at) VALUES (?, ?, ?)`,
-      )
-      .run(
-        "migration_209_strip_thinking_watermark",
-        String(below.rowid),
-        Date.now(),
-      );
-
-    await migrateStripThinkingFromConsolidated(getDb());
-
-    expect(blocks(below.id)).toEqual([
-      { type: "thinking", thinking: "x", signature: "s" },
-      { type: "text", text: "below" },
-    ]);
-    expect(blocks(above.id)).toEqual([{ type: "text", text: "above" }]);
-
-    // The watermark is cleared once the sweep reaches the end of the table.
-    const wm = getSqlite()
-      .query(`SELECT value FROM memory_checkpoints WHERE key = ?`)
-      .get("migration_209_strip_thinking_watermark");
-    expect(wm).toBeNull();
-  });
-});