@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/mcp/mcp-oauth-provider.ts

@@ -569,13 +569,21 @@ export class McpOAuthProvider implements OAuthClientProvider {
 
 // --- Static helpers ---
 
+/**
+ * Check whether OAuth tokens exist in the credential store for a server.
+ */
+export async function hasMcpOAuthTokens(serverId: string): Promise<boolean> {
+  const raw = await getSecureKeyAsync(tokensKey(serverId));
+  return raw != null && raw.length > 0;
+}
+
 /**
  * Delete all OAuth credentials for a given MCP server.
  * Used by `mcp remove` for cleanup.
  */
 export async function deleteMcpOAuthCredentials(
   serverId: string,
-): Promise<void> {
+): Promise<{ ok: boolean; failedKeys: string[] }> {
   const [tokensResult, clientResult, discoveryResult] = await Promise.all([
     deleteSecureKeyAsync(tokensKey(serverId)),
     deleteSecureKeyAsync(clientInfoKey(serverId)),
@@ -586,20 +594,23 @@ export async function deleteMcpOAuthCredentials(
     { key: "client_info", result: clientResult },
     { key: "discovery", result: discoveryResult },
   ];
-  const errors = results.filter((r) => r.result === "error").map((r) => r.key);
-  if (errors.length > 0) {
+  const failedKeys = results
+    .filter((r) => r.result === "error")
+    .map((r) => r.key);
+  if (failedKeys.length > 0) {
     log.warn(
-      { serverId, failedKeys: errors },
+      { serverId, failedKeys },
       "Some OAuth credentials could not be deleted from secure storage",
     );
   }
-  const hasErrors = errors.length > 0;
+  const ok = failedKeys.length === 0;
   log.info(
     { serverId },
-    hasErrors
-      ? "OAuth credential deletion completed with errors"
-      : "OAuth credentials deleted",
+    ok
+      ? "OAuth credentials deleted"
+      : "OAuth credential deletion completed with errors",
   );
+  return { ok, failedKeys };
 }
 
 // --- HTML rendering ---

package/src/memory/__tests__/301-create-watchdog-events.test.ts

@@ -0,0 +1,110 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { describe, expect, mock, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+// The migration opens the telemetry connection via getTelemetrySqlite(), which
+// routes through the singleton. Mock the path helper so the connection opens a
+// temp file we control, then mock the db-connection getter so it returns that
+// same file's Database.
+const tmpDir = mkdtempSync(join(tmpdir(), "wd-migration-"));
+const telemetryPath = join(tmpDir, "assistant-telemetry.db");
+let openedRaw: Database | null = null;
+
+mock.module("../../util/telemetry-db-path.js", () => ({
+  getTelemetryDbPath: () => telemetryPath,
+}));
+
+mock.module("../db-connection.js", () => ({
+  // The migration calls getTelemetrySqlite(); return our temp Database so the
+  // DDL runs against it. getSqliteFrom is used in other contexts but not by
+  // this migration when the mock is active.
+  getTelemetrySqlite: () => openedRaw,
+  getSqliteFrom: (db: unknown) =>
+    (db as unknown as { $client: Database }).$client,
+}));
+
+import { createWatchdogEventsTable } from "../migrations/301-create-watchdog-events.js";
+import * as schema from "../schema.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function openTelemetryRaw(): Database {
+  openedRaw = new Database(telemetryPath);
+  return openedRaw;
+}
+
+function columnNames(raw: Database): string[] {
+  return (
+    raw.query("PRAGMA table_info(watchdog_events)").all() as Array<{
+      name: string;
+    }>
+  ).map((c) => c.name);
+}
+
+function indexNames(raw: Database): string[] {
+  return (
+    raw.query("PRAGMA index_list(watchdog_events)").all() as Array<{
+      name: string;
+    }>
+  ).map((i) => i.name);
+}
+
+describe("migration 300: watchdog_events table on telemetry DB", () => {
+  test("creates the table with the expected columns", () => {
+    const raw = openTelemetryRaw();
+    const { db } = createTestDb();
+
+    createWatchdogEventsTable(db);
+
+    expect(columnNames(raw)).toEqual([
+      "id",
+      "created_at",
+      "check_name",
+      "value",
+      "detail",
+    ]);
+  });
+
+  test("creates the (created_at, id) cursor index", () => {
+    const raw = openTelemetryRaw();
+    const { db } = createTestDb();
+
+    createWatchdogEventsTable(db);
+
+    expect(indexNames(raw)).toContain("idx_watchdog_events_created_at_id");
+    const columns = (
+      raw
+        .query("PRAGMA index_info(idx_watchdog_events_created_at_id)")
+        .all() as Array<{ name: string }>
+    ).map((c) => c.name);
+    expect(columns).toEqual(["created_at", "id"]);
+  });
+
+  test("is idempotent — re-run is a no-op and preserves existing rows", () => {
+    const raw = openTelemetryRaw();
+    const { db } = createTestDb();
+
+    createWatchdogEventsTable(db);
+    raw.exec(/*sql*/ `
+      INSERT INTO watchdog_events (id, created_at, check_name, value)
+      VALUES ('wd-1', 1000, 'event_loop_blocked', 60000)
+    `);
+
+    expect(() => createWatchdogEventsTable(db)).not.toThrow();
+
+    const rows = raw.query("SELECT id FROM watchdog_events").all();
+    expect(rows).toEqual([{ id: "wd-1" }]);
+    expect(
+      indexNames(raw).filter(
+        (name) => name === "idx_watchdog_events_created_at_id",
+      ),
+    ).toHaveLength(1);
+  });
+});

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

@@ -161,6 +161,14 @@ mock.module("../conversation-crud.js", () => ({
       title: "Source conversation",
     };
   },
+  // Mirrors the real `isConversationProcessing` which reads the persisted
+  // `processing_started_at` column. In tests, the mock registry
+  // (`loadedConversations`) is the source of truth — a conversation id
+  // present with `processing: true` simulates a mid-turn conversation.
+  isConversationProcessing: (id: string) => {
+    const entry = loadedConversations[id];
+    return entry?.processing ?? false;
+  },
   forkConversationForRetrospective: async (params: {
     conversationId: string;
     throughMessageId?: string;

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__/watchdog-events-store.test.ts

@@ -0,0 +1,161 @@
+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/compaction-ledger-store.ts

@@ -0,0 +1,107 @@
+import { and, desc, eq, lte } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
+
+import { type DrizzleDb, getDb } from "./db-connection.js";
+import { conversationCompactionEvents } from "./schema.js";
+
+export interface CompactionEvent {
+  /** Wall-clock time the compaction ran (= `conversations.context_compacted_at`). */
+  compactedAt: number;
+  summary: string;
+  /** Count of leading persisted messages behind this compaction's summary. */
+  compactedMessageCount: number;
+}
+
+/**
+ * Append a compaction event to the ledger. Called alongside the
+ * `conversations` cache update on every compaction.
+ */
+export function appendCompactionEvent(
+  conversationId: string,
+  event: CompactionEvent,
+): void {
+  const db = getDb();
+  db.insert(conversationCompactionEvents)
+    .values({
+      id: uuid(),
+      conversationId,
+      compactedAt: event.compactedAt,
+      summary: event.summary,
+      compactedMessageCount: event.compactedMessageCount,
+      createdAt: Date.now(),
+    })
+    .run();
+}
+
+/**
+ * The most recent compaction event whose `compactedAt` is at-or-before
+ * `atOrBefore`, or null if none (or `atOrBefore` is null). This is the fork
+ * inheritance rule: a compaction applies to a fork only if it happened before
+ * the message being forked from.
+ */
+export function getLatestCompactionEventAtOrBefore(
+  conversationId: string,
+  atOrBefore: number | null,
+): CompactionEvent | null {
+  if (atOrBefore == null) return null;
+  const db = getDb();
+  const row = db
+    .select({
+      compactedAt: conversationCompactionEvents.compactedAt,
+      summary: conversationCompactionEvents.summary,
+      compactedMessageCount: conversationCompactionEvents.compactedMessageCount,
+    })
+    .from(conversationCompactionEvents)
+    .where(
+      and(
+        eq(conversationCompactionEvents.conversationId, conversationId),
+        lte(conversationCompactionEvents.compactedAt, atOrBefore),
+      ),
+    )
+    .orderBy(desc(conversationCompactionEvents.compactedAt))
+    .limit(1)
+    .get();
+  return row ?? null;
+}
+
+/**
+ * Copy the source conversation's ledger events with `compactedAt <=
+ * boundaryCreatedAt` into the fork, so the fork owns a correct ledger for its
+ * own future forks/compactions. Takes the active `db` so the copy joins the
+ * caller's transaction. No-op when the boundary is null.
+ */
+export function forkCompactionLedger(
+  db: DrizzleDb,
+  sourceConversationId: string,
+  forkConversationId: string,
+  boundaryCreatedAt: number | null,
+): void {
+  if (boundaryCreatedAt == null) return;
+  const events = db
+    .select({
+      compactedAt: conversationCompactionEvents.compactedAt,
+      summary: conversationCompactionEvents.summary,
+      compactedMessageCount: conversationCompactionEvents.compactedMessageCount,
+    })
+    .from(conversationCompactionEvents)
+    .where(
+      and(
+        eq(conversationCompactionEvents.conversationId, sourceConversationId),
+        lte(conversationCompactionEvents.compactedAt, boundaryCreatedAt),
+      ),
+    )
+    .all();
+  const now = Date.now();
+  for (const event of events) {
+    db.insert(conversationCompactionEvents)
+      .values({
+        id: uuid(),
+        conversationId: forkConversationId,
+        compactedAt: event.compactedAt,
+        summary: event.summary,
+        compactedMessageCount: event.compactedMessageCount,
+        createdAt: now,
+      })
+      .run();
+  }
+}