@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

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/conversation-crud.ts

@@ -25,6 +25,7 @@ import { parseChannelId, parseInterfaceId } from "../channels/types.js";
 import { CHANNEL_IDS, isChannelId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import { findDisplayTurnEndIndex } from "../conversations/message-consolidation.js";
+import { findConversation } from "../daemon/conversation-registry.js";
 import { conversationMetadataSyncTag } from "../daemon/message-types/sync.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { clearAllConversationIds } from "../home/feed-writer.js";
@@ -304,6 +305,7 @@ export interface ConversationRow {
   inferenceProfileSessionId: string | null;
   inferenceProfileExpiresAt: number | null;
   lastNotifiedInferenceProfile: string | null;
+  processingStartedAt: number | null;
 }
 
 export const parseConversation = createRowMapper<
@@ -339,6 +341,7 @@ export const parseConversation = createRowMapper<
   inferenceProfileSessionId: "inferenceProfileSessionId",
   inferenceProfileExpiresAt: "inferenceProfileExpiresAt",
   lastNotifiedInferenceProfile: "lastNotifiedInferenceProfile",
+  processingStartedAt: "processingStartedAt",
 });
 
 /** Allowed values for the `role` column on `messages`. */
@@ -2180,6 +2183,41 @@ export function unarchiveConversation(id: string): boolean {
   return true;
 }
 
+/**
+ * Persist the processing-start timestamp for a conversation. Called by
+ * `Conversation.setProcessing(true)` so out-of-process callers can detect
+ * mid-turn state by reading the `conversations` row directly. Pass `null`
+ * to clear (turn ended).
+ */
+export function setConversationProcessingStartedAt(
+  id: string,
+  startedAt: number | null,
+): void {
+  rawRun(
+    "UPDATE conversations SET processing_started_at = ? WHERE id = ?",
+    startedAt,
+    id,
+  );
+}
+
+/**
+ * Read whether a conversation is currently processing. Checks the in-memory
+ * `Conversation._processing` flag first (hot path for resident conversations),
+ * falling back to the persisted `processing_started_at` column for cold
+ * (evicted / never-loaded) conversations. This is the single entry point for
+ * processing state — callers don't need to layer `findConversation` themselves.
+ * Returns `false` when the conversation row doesn't exist.
+ */
+export function isConversationProcessing(id: string): boolean {
+  const inMemory = findConversation(id)?.isProcessing();
+  if (inMemory != null) return inMemory;
+  const row = rawGet<{ processing_started_at: number | null }>(
+    "SELECT processing_started_at FROM conversations WHERE id = ?",
+    id,
+  );
+  return row?.processing_started_at != null;
+}
+
 /**
  * Set or clear the `surfaced_at` promotion marker for a conversation.
  *

package/src/memory/db-connection.ts

@@ -8,6 +8,7 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 import { getLogsDbPath } from "../util/logs-db-path.js";
 import { getMemoryDbPath } from "../util/memory-db-path.js";
 import { ensureDataDir, getDbPath } from "../util/platform.js";
+import { getTelemetryDbPath } from "../util/telemetry-db-path.js";
 import { clearStoredDb, getStoredDb, setStoredDb } from "./db-singleton.js";
 import * as schema from "./schema.js";
 
@@ -136,7 +137,7 @@ export function getSqliteFrom(drizzleDb: DrizzleDb): Database {
  * path so this file stays import-light. Callers tolerate a `null` result.
  */
 function openDedicatedDb(
-  key: "logs" | "memory",
+  key: "logs" | "memory" | "telemetry",
   dbPath: string,
 ): DrizzleDb | null {
   assertTestDbIsIsolated();
@@ -192,11 +193,28 @@ export function getMemorySqlite(): Database | null {
   return db ? getSqliteFrom(db) : null;
 }
 
+/**
+ * The telemetry database (`assistant-telemetry.db`), opened lazily as its own
+ * connection. Houses telemetry event tables (starting with `watchdog_events`).
+ * Returns `null` if the file cannot be opened (logged; the daemon stays up).
+ */
+export function getTelemetryDb(): DrizzleDb | null {
+  const existing = getStoredDb<DrizzleDb>("telemetry");
+  if (existing) return existing;
+  return openDedicatedDb("telemetry", getTelemetryDbPath());
+}
+
+/** Underlying bun:sqlite Database for the telemetry connection, or `null`. */
+export function getTelemetrySqlite(): Database | null {
+  const db = getTelemetryDb();
+  return db ? getSqliteFrom(db) : null;
+}
+
 /**
  * Reset all DB singletons. Used by production callers that need to close the
  * live connections so the files can be replaced (post-migration, post-restore,
- * post-vbundle-import) and on graceful shutdown. Clears the main, logs, and
- * memory slots together so none lingers open against a swapped-out file.
+ * post-vbundle-import) and on graceful shutdown. Clears the main, logs, memory,
+ * and telemetry slots together so none lingers open against a swapped-out file.
  *
  * Tests should use `resetDbForTesting()` from
  * `__tests__/db-test-helpers.ts` instead so they don't depend on this
@@ -206,4 +224,5 @@ export function resetDb(): void {
   clearStoredDb("main");
   clearStoredDb("logs");
   clearStoredDb("memory");
+  clearStoredDb("telemetry");
 }