@vellumai/assistant 0.7.2 → 0.8.0

package/src/daemon/profiler-run-store.ts

@@ -73,7 +73,7 @@ const DEFAULT_MIN_FREE_MB = 200;
 
 // ── Result type ─────────────────────────────────────────────────────────
 
-export interface ProfilerSweepResult {
+interface ProfilerSweepResult {
   /** Number of completed runs pruned during this sweep. */
   prunedCount: number;
   /** Total bytes freed by pruning. */
@@ -159,7 +159,7 @@ function getFreeDiskBytes(path: string): number {
 // ── Core operations ─────────────────────────────────────────────────────
 
 /** Options for {@link rescanRuns}. */
-export interface RescanRunsOptions {
+interface RescanRunsOptions {
   /**
    * When true, skip all `writeManifest()` calls — just read existing
    * manifests and recompute sizes without mutating the filesystem.
@@ -384,7 +384,7 @@ export function runProfilerSweep(): ProfilerSweepResult {
 // health-endpoint reporting and control-plane polling.
 
 /** Budget state for the active profiler run. */
-export interface ProfilerBudgetStatus {
+interface ProfilerBudgetStatus {
   /** Configured maximum bytes across all runs. */
   maxBytes: number;
   /** Bytes remaining before the byte-count budget is exceeded. */
@@ -398,7 +398,7 @@ export interface ProfilerBudgetStatus {
 }
 
 /** Summary of the most recently completed profiler run. */
-export interface ProfilerLastCompletedRun {
+interface ProfilerLastCompletedRun {
   runId: string;
   totalBytes: number;
   artifactCount: number;
@@ -407,7 +407,7 @@ export interface ProfilerLastCompletedRun {
 }
 
 /** Full runtime status snapshot for health-endpoint embedding. */
-export interface ProfilerRuntimeStatus {
+interface ProfilerRuntimeStatus {
   /** Whether profiling is enabled (env vars present). */
   enabled: boolean;
   /** The profiling mode ("cpu", "heap", "cpu+heap"), or null when disabled. */

package/src/daemon/tool-setup-types.ts

@@ -21,8 +21,8 @@ export interface ToolSetupContext extends SurfaceConversationContext {
   abortController: AbortController | null;
   /** When set, only tools in this set may execute during the current turn. */
   allowedToolNames?: Set<string>;
-  /** Conversation memory policy used to propagate scopeId into ToolContext. */
-  memoryPolicy: { scopeId: string };
+  /** Turn-scoped disk-pressure cleanup mode flag. */
+  diskPressureCleanupModeActive?: boolean;
   /** True when the conversation has no connected client (HTTP-only path). */
   hasNoClient?: boolean;
   /** When true, the conversation is executing a task run and must not become interactive. */

package/src/documents/document-store.ts

@@ -0,0 +1,119 @@
+/**
+ * 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 { rawGet, 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",
+    };
+  }
+}
+
+/** Update persisted document content (append or replace). */
+export function updateDocumentContent(
+  surfaceId: string,
+  markdown: string,
+  mode: string,
+): void {
+  try {
+    const existing = rawGet<{ content: string }>(
+      /*sql*/ `SELECT content FROM documents WHERE surface_id = ?`,
+      surfaceId,
+    );
+    if (!existing) {
+      log.info({ surfaceId }, "No persisted document to update");
+      return;
+    }
+    const sep = mode === "append" && existing.content.length > 0 ? "\n\n" : "";
+    const newContent =
+      mode === "append" ? existing.content + sep + markdown : markdown;
+    const wordCount = newContent
+      .split(/\s+/)
+      .filter((w) => w.length > 0).length;
+    rawRun(
+      /*sql*/ `UPDATE documents SET content = ?, word_count = ?, updated_at = ? WHERE surface_id = ?`,
+      newContent,
+      wordCount,
+      Date.now(),
+      surfaceId,
+    );
+    log.info({ surfaceId, mode }, "Updated document content");
+  } catch (error) {
+    log.error({ err: error, surfaceId }, "Document content update error");
+  }
+}

package/src/filing/filing-service.ts

@@ -1,9 +1,13 @@
 import { existsSync, readFileSync } from "node:fs";
 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,10 +114,7 @@ export class FilingService {
 
   start(): void {
     const fullConfig = getConfig();
-    if (
-      isAssistantFeatureFlagEnabled("memory-v2-enabled", fullConfig) &&
-      fullConfig.memory.v2.enabled
-    ) {
+    if (fullConfig.memory.v2.enabled) {
       log.info("Filing service disabled — memory v2 is active");
       this._nextRunAt = null;
       this._nextCompactionAt = null;
@@ -195,6 +196,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 +250,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 +308,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,4 +1,4 @@
-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";
@@ -15,6 +15,7 @@ mock.module("../heartbeat-run-store.js", () => ({
   markStaleRunsAsMissed: () => 0,
   markStaleRunningAsError: () => 0,
   listHeartbeatRuns: () => [],
+  countCompletedHeartbeatRuns: () => 10,
 }));
 
 // Stub the in-process SSE hub so the writer's publish path is a
@@ -146,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[];
 }
@@ -174,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: () => {},
@@ -182,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 () => {
@@ -218,13 +214,13 @@ describe("heartbeat feed events", () => {
     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 });
@@ -232,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

@@ -15,6 +15,7 @@ import { getDb } from "../../memory/db-connection.js";
 import { initializeDb } from "../../memory/db-init.js";
 import {
   completeHeartbeatRun,
+  countCompletedHeartbeatRuns,
   insertPendingHeartbeatRun,
   listHeartbeatRuns,
   markStaleRunningAsError,
@@ -213,4 +214,39 @@ describe("heartbeat-run-store", () => {
     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);
+  });
 });

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

@@ -202,6 +202,19 @@ export function markStaleRunningAsError(
   return rawChanges();
 }
 
+/**
+ * Count the number of heartbeat runs that completed with status `ok`.
+ */
+export function countCompletedHeartbeatRuns(): number {
+  const db = getDb();
+  const row = db
+    .select({ count: sql<number>`count(*)` })
+    .from(heartbeatRuns)
+    .where(eq(heartbeatRuns.status, "ok"))
+    .get();
+  return row?.count ?? 0;
+}
+
 /**
  * List heartbeat runs ordered by `scheduledFor` descending.
  */