@vellumai/assistant 0.7.1 → 0.7.3

package/src/documents/document-store.ts

@@ -0,0 +1,85 @@
+/**
+ * Shared document persistence service.
+ *
+ * Extracted from documents-routes.ts so that both HTTP route handlers and
+ * background jobs (e.g. proactive artifact generation) can persist documents
+ * without going through the HTTP layer.
+ */
+import { rawRun } from "../memory/raw-query.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("document-store");
+
+// ---------------------------------------------------------------------------
+// Junction table helper
+// ---------------------------------------------------------------------------
+
+/** Insert a document–conversation association (idempotent via INSERT OR IGNORE). */
+export function addDocumentConversation(
+  surfaceId: string,
+  conversationId: string,
+): void {
+  rawRun(
+    /*sql*/ `INSERT OR IGNORE INTO document_conversations (surface_id, conversation_id, created_at) VALUES (?, ?, ?)`,
+    surfaceId,
+    conversationId,
+    Date.now(),
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Document persistence
+// ---------------------------------------------------------------------------
+
+export function saveDocument(params: {
+  surfaceId: string;
+  conversationId: string;
+  title: string;
+  content: string;
+  wordCount: number;
+}): { success: true; surfaceId: string } | { success: false; error: string } {
+  try {
+    const now = Date.now();
+    rawRun(
+      `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(surface_id) DO UPDATE SET
+         title = excluded.title,
+         content = excluded.content,
+         word_count = excluded.word_count,
+         updated_at = excluded.updated_at`,
+      params.surfaceId,
+      params.conversationId,
+      params.title,
+      params.content,
+      params.wordCount,
+      now,
+      now,
+    );
+    log.info(
+      { surfaceId: params.surfaceId, title: params.title },
+      "Saved document",
+    );
+
+    // Best-effort: associate the document with the conversation.
+    // Failures (e.g. migration not yet applied, table missing) must not
+    // cause the save response to report failure — the document itself is
+    // already persisted at this point.
+    try {
+      addDocumentConversation(params.surfaceId, params.conversationId);
+    } catch (err) {
+      log.warn(
+        { err, surfaceId: params.surfaceId },
+        "Failed to record document–conversation association",
+      );
+    }
+
+    return { success: true, surfaceId: params.surfaceId };
+  } catch (error) {
+    log.error({ err: error, surfaceId: params.surfaceId }, "Save error");
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}

package/src/events/tool-audit-listener.ts

@@ -2,6 +2,7 @@ import {
   recordToolInvocation,
   type ToolInvocationRecord,
 } from "../memory/tool-usage-store.js";
+import { redactSecrets } from "../security/secret-scanner.js";
 import type {
   ToolLifecycleEvent,
   ToolLifecycleEventHandler,
@@ -40,7 +41,7 @@ function toInvocationRecord(
         conversationId: event.conversationId,
         toolName: event.toolName,
         input: stringifyInput(event.input),
-        result: event.result.content.slice(0, RESULT_PREVIEW_LIMIT),
+        result: redactSecrets(event.result.content).slice(0, RESULT_PREVIEW_LIMIT),
         decision: event.decision,
         riskLevel: event.riskLevel,
         matchedTrustRuleId: event.matchedTrustRuleId,

package/src/filing/filing-service.ts

@@ -4,6 +4,11 @@ import { join } from "node:path";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
+import {
+  checkDiskPressureBackgroundGate,
+  diskPressureBackgroundSkipLogFields,
+  shouldLogDiskPressureBackgroundSkip,
+} from "../daemon/disk-pressure-background-gate.js";
 import { processMessage } from "../daemon/process-message.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getLogger } from "../util/logger.js";
@@ -110,11 +115,8 @@ export class FilingService {
 
   start(): void {
     const fullConfig = getConfig();
-    if (
-      isAssistantFeatureFlagEnabled("memory-v2-enabled", fullConfig) &&
-      fullConfig.memory.v2.enabled
-    ) {
-      log.info("Filing service disabled — memory v2 is active");
+    if (isAssistantFeatureFlagEnabled("memory-v2-enabled", fullConfig)) {
+      log.info("Filing service disabled — memory v2 flag is set");
       this._nextRunAt = null;
       this._nextCompactionAt = null;
       return;
@@ -195,6 +197,10 @@ export class FilingService {
     const config = getConfig().filing;
     if (!force && !config.enabled) return false;
 
+    if (!force && this.shouldSkipForDiskPressure("filing")) {
+      return false;
+    }
+
     if (
       !force &&
       !this.isWithinActiveHoursNow(
@@ -245,6 +251,10 @@ export class FilingService {
     const config = getConfig().filing;
     if (!force && !config.compactionEnabled) return false;
 
+    if (!force && this.shouldSkipForDiskPressure("compaction")) {
+      return false;
+    }
+
     if (
       !force &&
       !this.isWithinActiveHoursNow(
@@ -299,6 +309,21 @@ export class FilingService {
     this._nextCompactionAt = Date.now() + intervalMs;
   }
 
+  private shouldSkipForDiskPressure(source: "filing" | "compaction"): boolean {
+    const diskPressureGate = checkDiskPressureBackgroundGate("background-work");
+    if (diskPressureGate.action === "allow") return false;
+    if (shouldLogDiskPressureBackgroundSkip(`filing-service:${source}`)) {
+      log.warn(
+        {
+          source,
+          ...diskPressureBackgroundSkipLogFields(diskPressureGate),
+        },
+        "Filing service skipped during disk pressure cleanup mode",
+      );
+    }
+    return true;
+  }
+
   private hasBufferContent(): boolean {
     const bufferPath = join(getWorkspaceDir(), "pkb", "buffer.md");
     if (!existsSync(bufferPath)) return false;

package/src/heartbeat/__tests__/heartbeat-feed-event.test.ts

@@ -1,10 +1,23 @@
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 let workspaceDir: string;
 
+// Stub the heartbeat run store so HeartbeatService doesn't hit the real DB.
+mock.module("../heartbeat-run-store.js", () => ({
+  insertPendingHeartbeatRun: () => "mock-run-id",
+  startHeartbeatRun: () => true,
+  completeHeartbeatRun: () => true,
+  skipHeartbeatRun: () => true,
+  supersedePendingRun: () => true,
+  markStaleRunsAsMissed: () => 0,
+  markStaleRunningAsError: () => 0,
+  listHeartbeatRuns: () => [],
+  countCompletedHeartbeatRuns: () => 10,
+}));
+
 // Stub the in-process SSE hub so the writer's publish path is a
 // no-op in these tests.
 const publishSpy = mock<(event: unknown) => Promise<void>>(async () => {});
@@ -60,12 +73,10 @@ mock.module("../../config/loader.js", () => ({
   getConfig: () => stubConfig,
   getConfigReadOnly: () => stubConfig,
   loadConfig: () => stubConfig,
-  saveConfig: () => {},
   invalidateConfigCache: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   applyNestedDefaults: (c: unknown) => c,
-  deepMergeMissing: (a: unknown) => a,
   deepMergeOverwrite: (a: unknown) => a,
   mergeDefaultWorkspaceConfig: () => {},
   getNestedValue: () => undefined,
@@ -136,6 +147,7 @@ interface OnDiskItem {
 }
 
 function readFeedItems(): OnDiskItem[] {
+  if (!existsSync(getHomeFeedPath())) return [];
   const raw = JSON.parse(readFileSync(getHomeFeedPath(), "utf-8"));
   return raw.items as OnDiskItem[];
 }
@@ -164,7 +176,7 @@ afterEach(() => {
 });
 
 describe("heartbeat feed events", () => {
-  test("successful heartbeat emits feed event with priority 30 and no urgency", async () => {
+  test("successful heartbeat without an alert does not emit a feed event", async () => {
     _testProcessMessage = async () => ({ messageId: "msg-1" });
     const service = new HeartbeatService({
       alerter: () => {},
@@ -172,18 +184,12 @@ describe("heartbeat feed events", () => {
 
     await service.runOnce({ force: true });
 
-    // Give the fire-and-forget emitFeedEvent time to flush.
+    // Give any fire-and-forget surfacing work time to flush.
     await new Promise((r) => setTimeout(r, 100));
 
     const items = readFeedItems();
     const heartbeatItem = items.find((i) => i.title === "Heartbeat");
-    expect(heartbeatItem).toBeDefined();
-    expect(heartbeatItem!.summary).toBe(
-      "Periodic check completed. Tap to see details.",
-    );
-    expect(heartbeatItem!.priority).toBe(30);
-    expect(heartbeatItem!.urgency).toBeUndefined();
-    expect(heartbeatItem!.source).toBe("assistant");
+    expect(heartbeatItem).toBeUndefined();
   });
 
   test("failed heartbeat emits feed event with priority 55 and urgency medium", async () => {
@@ -200,23 +206,21 @@ describe("heartbeat feed events", () => {
     await new Promise((r) => setTimeout(r, 100));
 
     const items = readFeedItems();
-    const heartbeatItem = items.find((i) => i.title === "Heartbeat");
+    const heartbeatItem = items.find((i) => i.title === "Heartbeat Failed");
     expect(heartbeatItem).toBeDefined();
-    expect(heartbeatItem!.summary).toBe(
-      "Heartbeat check failed. Check logs for details.",
-    );
+    expect(heartbeatItem!.summary).toContain("LLM call failed");
     expect(heartbeatItem!.priority).toBe(55);
-    expect(heartbeatItem!.urgency).toBe("medium");
+    expect(heartbeatItem!.urgency).toBe("high");
     expect(heartbeatItem!.source).toBe("assistant");
   });
 
-  test("dedupKey uses date for daily dedup", async () => {
+  test("repeated successful heartbeats without alerts stay silent", async () => {
     _testProcessMessage = async () => ({ messageId: "msg-1" });
     const service = new HeartbeatService({
       alerter: () => {},
     });
 
-    // Run twice — same day should dedup to one item.
+    // Run twice — neither should create a generic success item.
     await service.runOnce({ force: true });
     await new Promise((r) => setTimeout(r, 100));
     await service.runOnce({ force: true });
@@ -224,9 +228,6 @@ describe("heartbeat feed events", () => {
 
     const items = readFeedItems();
     const heartbeatItems = items.filter((i) => i.title === "Heartbeat");
-    expect(heartbeatItems).toHaveLength(1);
-
-    const today = new Date().toISOString().split("T")[0];
-    expect(heartbeatItems[0]!.id).toBe(`emit:assistant:heartbeat:ok:${today}`);
+    expect(heartbeatItems).toHaveLength(0);
   });
 });

package/src/heartbeat/__tests__/heartbeat-run-store.test.ts

@@ -0,0 +1,252 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import { mock } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (value: string) => value,
+}));
+
+import { sql } from "drizzle-orm";
+
+import { getDb } from "../../memory/db-connection.js";
+import { initializeDb } from "../../memory/db-init.js";
+import {
+  completeHeartbeatRun,
+  countCompletedHeartbeatRuns,
+  insertPendingHeartbeatRun,
+  listHeartbeatRuns,
+  markStaleRunningAsError,
+  markStaleRunsAsMissed,
+  skipHeartbeatRun,
+  startHeartbeatRun,
+  supersedePendingRun,
+} from "../heartbeat-run-store.js";
+
+initializeDb();
+
+describe("heartbeat-run-store", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM heartbeat_runs");
+  });
+
+  test("insertPendingHeartbeatRun creates row with status pending and null timing", () => {
+    const scheduledFor = Date.now();
+    const id = insertPendingHeartbeatRun(scheduledFor);
+    expect(id).toBeTruthy();
+
+    const rows = listHeartbeatRuns();
+    expect(rows).toHaveLength(1);
+    expect(rows[0].id).toBe(id);
+    expect(rows[0].status).toBe("pending");
+    expect(rows[0].scheduledFor).toBe(scheduledFor);
+    expect(rows[0].startedAt).toBeNull();
+    expect(rows[0].finishedAt).toBeNull();
+    expect(rows[0].durationMs).toBeNull();
+    expect(rows[0].error).toBeNull();
+    expect(rows[0].conversationId).toBeNull();
+    expect(rows[0].skipReason).toBeNull();
+  });
+
+  test("startHeartbeatRun transitions pending -> running and sets startedAt", () => {
+    const id = insertPendingHeartbeatRun(Date.now());
+    const ok = startHeartbeatRun(id);
+    expect(ok).toBe(true);
+
+    const rows = listHeartbeatRuns();
+    expect(rows[0].status).toBe("running");
+    expect(rows[0].startedAt).toBeGreaterThan(0);
+  });
+
+  test("startHeartbeatRun returns false for non-pending row", () => {
+    const id = insertPendingHeartbeatRun(Date.now());
+
+    // Start once — succeeds
+    expect(startHeartbeatRun(id)).toBe(true);
+    // Start again — fails (already running)
+    expect(startHeartbeatRun(id)).toBe(false);
+
+    // Also: superseded row cannot be started
+    const id2 = insertPendingHeartbeatRun(Date.now());
+    supersedePendingRun(id2);
+    expect(startHeartbeatRun(id2)).toBe(false);
+  });
+
+  test("completeHeartbeatRun transitions running -> ok with conversationId", () => {
+    const id = insertPendingHeartbeatRun(Date.now());
+    startHeartbeatRun(id);
+    const ok = completeHeartbeatRun(id, {
+      status: "ok",
+      conversationId: "conv-123",
+    });
+    expect(ok).toBe(true);
+
+    const rows = listHeartbeatRuns();
+    expect(rows[0].status).toBe("ok");
+    expect(rows[0].conversationId).toBe("conv-123");
+    expect(rows[0].finishedAt).toBeGreaterThan(0);
+    expect(rows[0].durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  test("completeHeartbeatRun transitions running -> error with truncated error", () => {
+    const id = insertPendingHeartbeatRun(Date.now());
+    startHeartbeatRun(id);
+
+    // 3KB string — should be truncated to 2000 chars
+    const longError = "x".repeat(3000);
+    const ok = completeHeartbeatRun(id, {
+      status: "error",
+      error: longError,
+    });
+    expect(ok).toBe(true);
+
+    const rows = listHeartbeatRuns();
+    expect(rows[0].status).toBe("error");
+    expect(rows[0].error).toHaveLength(2000);
+  });
+
+  test("completeHeartbeatRun returns false when status is not running (CAS)", () => {
+    const id = insertPendingHeartbeatRun(Date.now());
+    startHeartbeatRun(id);
+    // Complete with timeout
+    completeHeartbeatRun(id, { status: "timeout" });
+    // Try to complete again with ok — should fail (already timeout)
+    const ok = completeHeartbeatRun(id, { status: "ok" });
+    expect(ok).toBe(false);
+
+    const rows = listHeartbeatRuns();
+    expect(rows[0].status).toBe("timeout");
+  });
+
+  test("skipHeartbeatRun transitions pending -> skipped with reason", () => {
+    const id = insertPendingHeartbeatRun(Date.now());
+    const ok = skipHeartbeatRun(id, "outside_active_hours");
+    expect(ok).toBe(true);
+
+    const rows = listHeartbeatRuns();
+    expect(rows[0].status).toBe("skipped");
+    expect(rows[0].skipReason).toBe("outside_active_hours");
+  });
+
+  test("skipHeartbeatRun returns false for non-pending row", () => {
+    const id = insertPendingHeartbeatRun(Date.now());
+    startHeartbeatRun(id);
+    const ok = skipHeartbeatRun(id, "disabled");
+    expect(ok).toBe(false);
+  });
+
+  test("supersedePendingRun transitions pending -> superseded", () => {
+    const id = insertPendingHeartbeatRun(Date.now());
+    const ok = supersedePendingRun(id);
+    expect(ok).toBe(true);
+
+    const rows = listHeartbeatRuns();
+    expect(rows[0].status).toBe("superseded");
+  });
+
+  test("supersedePendingRun returns false for non-pending row", () => {
+    const id = insertPendingHeartbeatRun(Date.now());
+    startHeartbeatRun(id);
+    const ok = supersedePendingRun(id);
+    expect(ok).toBe(false);
+  });
+
+  test("markStaleRunsAsMissed transitions old pending rows to missed", () => {
+    const now = Date.now();
+    // Two old pending rows
+    const id1 = insertPendingHeartbeatRun(now - 10 * 60 * 1000);
+    const id2 = insertPendingHeartbeatRun(now - 8 * 60 * 1000);
+    // One recent pending row
+    const id3 = insertPendingHeartbeatRun(now);
+
+    const count = markStaleRunsAsMissed(5 * 60 * 1000);
+    expect(count).toBe(2);
+
+    const rows = listHeartbeatRuns();
+    const byId = Object.fromEntries(rows.map((r) => [r.id, r]));
+    expect(byId[id1].status).toBe("missed");
+    expect(byId[id2].status).toBe("missed");
+    expect(byId[id3].status).toBe("pending");
+  });
+
+  test("markStaleRunningAsError transitions old running rows to error", () => {
+    const now = Date.now();
+    const id = insertPendingHeartbeatRun(now - 60 * 60 * 1000);
+    startHeartbeatRun(id);
+
+    // Backdate started_at to simulate a long-running process
+    const db = getDb();
+    const backdatedStartedAt = now - 60 * 60 * 1000;
+    db.run(
+      sql`UPDATE heartbeat_runs SET started_at = ${backdatedStartedAt} WHERE id = ${id}`,
+    );
+
+    const count = markStaleRunningAsError(45 * 60 * 1000);
+    expect(count).toBe(1);
+
+    const rows = listHeartbeatRuns();
+    expect(rows[0].status).toBe("error");
+    expect(rows[0].error).toBe("Process crashed or restarted during execution");
+  });
+
+  test("listHeartbeatRuns returns rows ordered by scheduledFor desc", () => {
+    const now = Date.now();
+    insertPendingHeartbeatRun(now - 2000);
+    insertPendingHeartbeatRun(now);
+    insertPendingHeartbeatRun(now - 1000);
+
+    const rows = listHeartbeatRuns();
+    expect(rows).toHaveLength(3);
+    expect(rows[0].scheduledFor).toBe(now);
+    expect(rows[1].scheduledFor).toBe(now - 1000);
+    expect(rows[2].scheduledFor).toBe(now - 2000);
+  });
+
+  test("listHeartbeatRuns respects limit", () => {
+    const now = Date.now();
+    for (let i = 0; i < 5; i++) {
+      insertPendingHeartbeatRun(now + i);
+    }
+
+    const rows = listHeartbeatRuns(3);
+    expect(rows).toHaveLength(3);
+  });
+
+  test("countCompletedHeartbeatRuns counts only ok rows", () => {
+    const now = Date.now();
+
+    // Insert runs with various statuses
+    const id1 = insertPendingHeartbeatRun(now);
+    startHeartbeatRun(id1);
+    completeHeartbeatRun(id1, { status: "ok", conversationId: "conv-1" });
+
+    const id2 = insertPendingHeartbeatRun(now + 1);
+    startHeartbeatRun(id2);
+    completeHeartbeatRun(id2, { status: "error", error: "something broke" });
+
+    const id3 = insertPendingHeartbeatRun(now + 2);
+    skipHeartbeatRun(id3, "disabled");
+
+    const id4 = insertPendingHeartbeatRun(now + 3);
+    startHeartbeatRun(id4);
+    completeHeartbeatRun(id4, { status: "ok", conversationId: "conv-2" });
+
+    expect(countCompletedHeartbeatRuns()).toBe(2);
+  });
+
+  test("countCompletedHeartbeatRuns returns 0 when no ok rows exist", () => {
+    const now = Date.now();
+
+    const id1 = insertPendingHeartbeatRun(now);
+    startHeartbeatRun(id1);
+    completeHeartbeatRun(id1, { status: "error", error: "fail" });
+
+    const id2 = insertPendingHeartbeatRun(now + 1);
+    skipHeartbeatRun(id2, "outside_active_hours");
+
+    expect(countCompletedHeartbeatRuns()).toBe(0);
+  });
+});