@vellumai/assistant 0.7.2 → 0.8.0

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -0,0 +1,268 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    filing: {
+      enabled: true,
+      intervalMs: 60_000,
+      compactionEnabled: true,
+      compactionIntervalMs: 60_000,
+      activeHoursStart: null,
+      activeHoursEnd: null,
+    },
+    memory: {
+      enabled: true,
+      jobs: {
+        stalledJobTimeoutMs: 60_000,
+        slowLlmConcurrency: 1,
+        fastConcurrency: 1,
+        embedConcurrency: 1,
+      },
+      cleanup: {
+        enabled: true,
+        enqueueIntervalMs: 60_000,
+        conversationRetentionDays: 30,
+        llmRequestLogRetentionMs: 60_000,
+        traceEventRetentionDays: 30,
+      },
+      v2: {
+        enabled: false,
+        consolidation_interval_hours: 4,
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getConfigReadOnly: () => ({}),
+  applyNestedDefaults: (config: unknown) => config,
+  deepMergeOverwrite: (base: unknown) => base,
+  mergeDefaultWorkspaceConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+  API_KEY_PROVIDERS: [],
+  _appendQuarantineBulletin: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../daemon/disk-pressure-background-gate.js", () => ({
+  checkDiskPressureBackgroundGate: () => ({
+    action: "skip",
+    reason: "disk_pressure",
+    blockedCapability: "background-work",
+    status: {
+      enabled: true,
+      state: "critical",
+      locked: true,
+      acknowledged: true,
+      overrideActive: false,
+      effectivelyLocked: true,
+      lockId: "disk-pressure-test",
+      usagePercent: 98,
+      thresholdPercent: 95,
+      path: "/",
+      lastCheckedAt: "2026-05-05T00:00:00.000Z",
+      blockedCapabilities: ["agent-turns", "background-work", "remote-ingress"],
+      error: null,
+    },
+  }),
+  diskPressureBackgroundSkipLogFields: () => ({
+    reason: "disk_pressure",
+    thresholdPercent: 95,
+    usagePercent: 98,
+    blockedCapability: "background-work",
+    lockId: "disk-pressure-test",
+    path: "/",
+  }),
+  shouldLogDiskPressureBackgroundSkip: () => true,
+}));
+
+const mockProcessMessage = mock(() => Promise.resolve({ messageId: "msg-1" }));
+mock.module("../daemon/process-message.js", () => ({
+  processMessage: mockProcessMessage,
+  processMessageInBackground: mock(() =>
+    Promise.resolve({ messageId: "msg-bg" }),
+  ),
+  resolveTurnChannel: () => "vellum",
+  resolveTurnInterface: () => "vellum",
+}));
+
+const createdConversations: Array<{ conversationType: string }> = [];
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: mock(() => ({ id: "msg-1" })),
+  archiveConversation: mock(() => true),
+  batchSetDisplayOrders: mock(() => {}),
+  clearStrippedInjectionMetadataForConversation: mock(() => {}),
+  createConversation: (opts: { conversationType: string }) => {
+    createdConversations.push(opts);
+    return { id: "conv-1", ...opts };
+  },
+  countConversationsByScheduleJobId: mock(() => 0),
+  deleteMessageById: mock(() => {}),
+  clearAll: mock(() => ({ conversations: 0, messages: 0 })),
+  deleteConversation: mock(() => ({ memoryIds: [] })),
+  deleteLastExchange: mock(() => 0),
+  findAnalysisConversationFor: mock(() => null),
+  forkConversation: mock(() => ({ id: "conv-fork" })),
+  getConversationOverrideProfile: () => undefined,
+  getConversationOverrideProfileFromRow: () => undefined,
+  getConversationMemoryScopeId: () => "default",
+  getConversationOriginChannel: () => null,
+  getConversationOriginInterface: () => null,
+  getConversationRecentProvenanceTrustClass: () => null,
+  getConversationSource: () => null,
+  getAssistantMessageIdsInTurn: () => [],
+  getDisplayMetaForConversations: () => new Map(),
+  getLastAssistantTimestampBefore: () => null,
+  getLastUserTimestampBefore: () => null,
+  getMessageById: () => null,
+  getMessages: () => [],
+  getMessagesPaginated: () => ({ messages: [], hasMore: false }),
+  getTurnTimeBounds: () => null,
+  getConversation: () => null,
+  hasMessages: () => false,
+  messageMetadataSchema: { parse: (value: unknown) => value },
+  parseConversation: (row: unknown) => row,
+  provenanceFromTrustContext: () => ({ source: "user" }),
+  relinkAttachments: mock(() => {}),
+  selectSlackMetaCandidateMetadata: () => null,
+  setConversationOriginChannelIfUnset: mock(() => {}),
+  setConversationOriginInterfaceIfUnset: mock(() => {}),
+  setConversationInferenceProfile: mock(() => {}),
+  unarchiveConversation: mock(() => true),
+  updateMessageContent: mock(() => {}),
+  updateMessageContentAndMetadata: mock(() => {}),
+  updateMessageMetadata: mock(() => {}),
+  updateConversationContextWindow: mock(() => {}),
+  updateConversationSlackContextWatermark: mock(() => {}),
+  updateConversationTitle: mock(() => {}),
+  updateConversationUsage: mock(() => {}),
+  wipeConversation: mock(() => ({ memoryIds: [] })),
+}));
+
+mock.module("../memory/conversation-title-service.js", () => ({
+  GENERATING_TITLE: "Generating title...",
+  isReplaceableTitle: () => true,
+  queueGenerateConversationTitle: () => {},
+  queueRegenerateConversationTitle: () => {},
+}));
+
+const mockFailStalledJobs = mock(() => 0);
+const mockClaimMemoryJobs = mock(() => []);
+mock.module("../memory/jobs-store.js", () => ({
+  claimMemoryJobs: mockClaimMemoryJobs,
+  completeMemoryJob: mock(() => {}),
+  deferMemoryJob: mock(() => "deferred"),
+  EMBED_JOB_TYPES: [],
+  enqueueMemoryJob: mock(() => "job-1"),
+  enqueuePruneOldConversationsJob: mock(() => "job-prune-conv"),
+  enqueuePruneOldLlmRequestLogsJob: mock(() => "job-prune-llm"),
+  enqueuePruneOldTraceEventsJob: mock(() => "job-prune-trace"),
+  failMemoryJob: mock(() => {}),
+  failStalledJobs: mockFailStalledJobs,
+  getMemoryJobCounts: mock(() => ({})),
+  hasActiveJobOfType: mock(() => false),
+  resetRunningJobsToPending: mock(() => 0),
+  SLOW_LLM_JOB_TYPES: [],
+  upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),
+  upsertDebouncedJob: mock(() => "job-debounced"),
+}));
+
+const mockMaybeRunDbMaintenance = mock(() => {});
+mock.module("../memory/db-maintenance.js", () => ({
+  maybeRunDbMaintenance: mockMaybeRunDbMaintenance,
+}));
+
+mock.module("../memory/cleanup-schedule-state.js", () => ({
+  getLastScheduledCleanupEnqueueMs: () => 0,
+  markScheduledCleanupEnqueued: mock(() => {}),
+}));
+
+const { startFeedScheduler } = await import("../home/feed-scheduler.js");
+const { runMemoryJobsOnce } = await import("../memory/jobs-worker.js");
+const { FilingService } = await import("../filing/filing-service.js");
+const { WorkspaceHeartbeatService } =
+  await import("../workspace/heartbeat-service.js");
+
+describe("background workers disk pressure gate", () => {
+  beforeEach(() => {
+    mockProcessMessage.mockClear();
+    createdConversations.length = 0;
+    mockFailStalledJobs.mockClear();
+    mockClaimMemoryJobs.mockClear();
+    mockMaybeRunDbMaintenance.mockClear();
+  });
+
+  test("home feed scheduler skips producers while locked", async () => {
+    const gmailDigestRunner = mock(async () => null);
+    const rollupRunner = mock(async () => ({
+      wroteCount: 1,
+      skippedReason: "empty_items" as const,
+    }));
+    const handle = startFeedScheduler({
+      runOnStart: false,
+      gmailCountSource: async () => 0,
+      gmailDigestRunner,
+      rollupRunner,
+    });
+
+    const summary = await handle.runOnce(new Date("2026-05-05T12:00:00.000Z"));
+    handle.stop();
+
+    expect(summary).toEqual({ gmailDigestRan: false, rollupRan: false });
+    expect(gmailDigestRunner).not.toHaveBeenCalled();
+    expect(rollupRunner).not.toHaveBeenCalled();
+  });
+
+  test("memory jobs worker skips before claiming or maintenance writes", async () => {
+    const processed = await runMemoryJobsOnce({ enableScheduledCleanup: true });
+
+    expect(processed).toBe(0);
+    expect(mockFailStalledJobs).not.toHaveBeenCalled();
+    expect(mockClaimMemoryJobs).not.toHaveBeenCalled();
+    expect(mockMaybeRunDbMaintenance).not.toHaveBeenCalled();
+  });
+
+  test("filing service skips background LLM work while locked", async () => {
+    const service = new FilingService();
+
+    const ran = await service.runOnce();
+    const compacted = await service.runCompactionOnce();
+
+    expect(ran).toBe(false);
+    expect(compacted).toBe(false);
+    expect(createdConversations).toHaveLength(0);
+    expect(mockProcessMessage).not.toHaveBeenCalled();
+  });
+
+  test("filing service allows forced user-initiated runs while locked", async () => {
+    const service = new FilingService();
+
+    const ran = await service.runOnce({ force: true });
+    const compacted = await service.runCompactionOnce({ force: true });
+
+    expect(ran).toBe(true);
+    expect(compacted).toBe(true);
+    expect(createdConversations).toHaveLength(2);
+    expect(mockProcessMessage).toHaveBeenCalledTimes(2);
+  });
+
+  test("workspace heartbeat skips auto-commit checks while locked", async () => {
+    const getServices = mock(() => new Map());
+    const heartbeat = new WorkspaceHeartbeatService({ getServices });
+
+    const result = await heartbeat.check();
+
+    expect(result).toEqual({ checked: 0, committed: 0, skipped: 0, failed: 0 });
+    expect(getServices).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/call-constants.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
-import { isDeniedNumber } from "../calls/call-constants.js";
+import {
+  getEndCallListenWindowMs,
+  isDeniedNumber,
+} from "../calls/call-constants.js";
 
 describe("isDeniedNumber", () => {
   // Numbers that MUST be blocked
@@ -39,3 +42,9 @@ describe("isDeniedNumber", () => {
     });
   }
 });
+
+describe("getEndCallListenWindowMs", () => {
+  test("leaves a brief response window before task-complete hangup", () => {
+    expect(getEndCallListenWindowMs()).toBe(15_000);
+  });
+});

package/src/__tests__/call-controller.test.ts

@@ -105,11 +105,13 @@ mock.module("../security/credential-key.js", () => ({
 
 let mockConsultationTimeoutMs = 90_000;
 let mockSilenceTimeoutMs = 30_000;
+let mockEndCallListenWindowMs = 0;
 
 mock.module("../calls/call-constants.js", () => ({
   getMaxCallDurationMs: () => 12 * 60 * 1000,
   getUserConsultationTimeoutMs: () => mockConsultationTimeoutMs,
   getSilenceTimeoutMs: () => mockSilenceTimeoutMs,
+  getEndCallListenWindowMs: () => mockEndCallListenWindowMs,
 }));
 
 // ── Voice session bridge mock ────────────────────────────────────────
@@ -467,6 +469,7 @@ describe("call-controller", () => {
     // Reset consultation timeout to the default (long) value
     mockConsultationTimeoutMs = 90_000;
     mockSilenceTimeoutMs = 30_000;
+    mockEndCallListenWindowMs = 0;
     // Reset TTS config to defaults so per-test mutations don't leak.
     const cfg = loadConfig();
     cfg.services.tts.provider = "elevenlabs";
@@ -755,6 +758,130 @@ describe("call-controller", () => {
     controller.destroy();
   });
 
+  test("END_CALL waits through the listen window before completing", async () => {
+    mockEndCallListenWindowMs = 25;
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Thank you for calling, goodbye! ", "[END_CALL]"]),
+    );
+    const { session, relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("That is all, thanks");
+
+    expect(relay.endCalled).toBe(false);
+    expect(getCallSession(session.id)!.status).toBe("in_progress");
+
+    await new Promise((r) => setTimeout(r, 35));
+
+    expect(relay.endCalled).toBe(true);
+    const updatedSession = getCallSession(session.id);
+    expect(updatedSession!.status).toBe("completed");
+    expect(updatedSession!.endedAt).not.toBeNull();
+
+    controller.destroy();
+  });
+
+  test("delayed END_CALL completion skips side effects when session is already terminal", async () => {
+    mockEndCallListenWindowMs = 25;
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Thank you for calling, goodbye! ", "[END_CALL]"]),
+    );
+    const { session, relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("That is all, thanks");
+
+    const externalEndedAt = Date.now();
+    updateCallSession(session.id, {
+      status: "completed",
+      endedAt: externalEndedAt,
+    });
+
+    await new Promise((r) => setTimeout(r, 35));
+
+    expect(relay.endCalled).toBe(false);
+    const updatedSession = getCallSession(session.id);
+    expect(updatedSession!.status).toBe("completed");
+    expect(updatedSession!.endedAt).toBe(externalEndedAt);
+
+    controller.destroy();
+  });
+
+  test("callee speech during END_CALL listen window cancels pending completion", async () => {
+    mockEndCallListenWindowMs = 30;
+    const turnContents: string[] = [];
+    mockStartVoiceTurn.mockImplementation(
+      async (opts: {
+        content: string;
+        onTextDelta: (t: string) => void;
+        onComplete: () => void;
+      }) => {
+        turnContents.push(opts.content);
+        if (turnContents.length === 1) {
+          opts.onTextDelta("Goodbye! [END_CALL]");
+        } else {
+          opts.onTextDelta("Of course. I'm still here.");
+        }
+        opts.onComplete();
+        return { turnId: `run-${turnContents.length}`, abort: () => {} };
+      },
+    );
+    const { session, relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("That is all, thanks");
+    expect(relay.endCalled).toBe(false);
+
+    await controller.handleCallerUtterance("Wait, one more thing");
+    await new Promise((r) => setTimeout(r, 40));
+
+    expect(relay.endCalled).toBe(false);
+    expect(getCallSession(session.id)!.status).toBe("in_progress");
+    expect(turnContents).toContain("Wait, one more thing");
+    const allText = relay.sentTokens.map((t) => t.token).join("");
+    expect(allText).toContain("I'm still here.");
+
+    controller.destroy();
+  });
+
+  test("END_CALL listen window restores in_progress after clearing pending guardian input", async () => {
+    mockEndCallListenWindowMs = 30;
+    const turnContents: string[] = [];
+    mockStartVoiceTurn.mockImplementation(
+      async (opts: {
+        content: string;
+        onTextDelta: (t: string) => void;
+        onComplete: () => void;
+      }) => {
+        turnContents.push(opts.content);
+        if (turnContents.length === 1) {
+          opts.onTextDelta("Let me check. [ASK_GUARDIAN: Is this okay?]");
+        } else if (turnContents.length === 2) {
+          opts.onTextDelta("Never mind, goodbye. [END_CALL]");
+        } else {
+          opts.onTextDelta("I'm still here.");
+        }
+        opts.onComplete();
+        return { turnId: `run-${turnContents.length}`, abort: () => {} };
+      },
+    );
+    const { session, relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Can you ask?");
+    expect(controller.getPendingConsultationQuestionId()).not.toBeNull();
+    expect(getCallSession(session.id)!.status).toBe("waiting_on_user");
+
+    await controller.handleCallerUtterance("Actually never mind");
+    expect(controller.getPendingConsultationQuestionId()).toBeNull();
+    expect(getCallSession(session.id)!.status).toBe("in_progress");
+    expect(relay.endCalled).toBe(false);
+
+    await controller.handleCallerUtterance("Wait, one more thing");
+    await new Promise((r) => setTimeout(r, 40));
+
+    expect(relay.endCalled).toBe(false);
+    expect(getCallSession(session.id)!.status).toBe("in_progress");
+
+    controller.destroy();
+  });
+
   // ── handleUserAnswer ──────────────────────────────────────────────
 
   test("handleUserAnswer: returns true immediately and fires LLM asynchronously", async () => {

package/src/__tests__/call-conversation-messages.test.ts

@@ -54,10 +54,16 @@ function getLatestAssistantText(conversationId: string): string {
   const parsed = JSON.parse(latest.content) as Array<{
     type: string;
     text?: string;
+    surfaceType?: string;
+    data?: { summaryText?: string };
   }>;
   return parsed
-    .filter((b) => b.type === "text")
-    .map((b) => b.text ?? "")
+    .map((b) => {
+      if (b.type === "text") return b.text ?? "";
+      if (b.type === "ui_surface" && b.surfaceType === "call_summary")
+        return b.data?.summaryText ?? "";
+      return "";
+    })
     .join("");
 }