@vellumai/assistant 0.7.2 → 0.7.3

package/src/__tests__/assistant-event-hub.test.ts

@@ -356,6 +356,54 @@ describe("AssistantEventHub — re-entrancy / snapshot isolation", () => {
   });
 });
 
+// ── ClientEntry actorPrincipalId capture ────────────────────────────────────
+
+describe("AssistantEventHub — actorPrincipalId on ClientEntry", () => {
+  test("stores actorPrincipalId provided at subscribe time", () => {
+    const hub = new AssistantEventHub();
+
+    hub.subscribe({
+      type: "client" as const,
+      clientId: "client-with-principal",
+      interfaceId: "macos",
+      capabilities: ["host_bash"],
+      actorPrincipalId: "user-A",
+      callback: () => {},
+    });
+
+    expect(hub.getClientById("client-with-principal")?.actorPrincipalId).toBe(
+      "user-A",
+    );
+    expect(hub.getActorPrincipalIdForClient("client-with-principal")).toBe(
+      "user-A",
+    );
+  });
+
+  test("actorPrincipalId is undefined when omitted at subscribe time", () => {
+    const hub = new AssistantEventHub();
+
+    hub.subscribe({
+      type: "client" as const,
+      clientId: "client-no-principal",
+      interfaceId: "macos",
+      capabilities: ["host_bash"],
+      callback: () => {},
+    });
+
+    expect(
+      hub.getClientById("client-no-principal")?.actorPrincipalId,
+    ).toBeUndefined();
+    expect(
+      hub.getActorPrincipalIdForClient("client-no-principal"),
+    ).toBeUndefined();
+  });
+
+  test("getActorPrincipalIdForClient returns undefined for unknown clientId", () => {
+    const hub = new AssistantEventHub();
+    expect(hub.getActorPrincipalIdForClient("does-not-exist")).toBeUndefined();
+  });
+});
+
 // ── capabilityForMessageType — host-prefix routing ───────────────────────────
 
 describe("capabilityForMessageType — host-prefix routing", () => {

package/src/__tests__/assistant-event.test.ts

@@ -4,7 +4,6 @@ import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
   formatSseFrame,
   formatSseHeartbeat,
-  formatSseHeartbeatWithData,
 } from "../runtime/assistant-event.js";
 
 // ── Type / shape tests ────────────────────────────────────────────────────────
@@ -126,12 +125,3 @@ describe("formatSseHeartbeat", () => {
     expect(formatSseHeartbeat().startsWith(":")).toBe(true);
   });
 });
-
-describe("formatSseHeartbeatWithData", () => {
-  test("includes both a comment and a data-bearing event", () => {
-    const hb = formatSseHeartbeatWithData();
-    expect(hb).toContain(": heartbeat\n\n");
-    expect(hb).toContain("event: assistant_event\n");
-    expect(hb).toContain('data: {"type":"heartbeat"}\n');
-  });
-});

package/src/__tests__/assistant-events-sse-hardening.test.ts

@@ -261,8 +261,7 @@ describe("SSE route — heartbeat", () => {
     reader.cancel();
 
     const text = new TextDecoder().decode(value);
-    expect(text).toContain(": heartbeat");
-    expect(text).toContain('{"type":"heartbeat"}');
+    expect(text).toBe(": heartbeat\n\n");
   });
 
   test("emits multiple heartbeats over time", async () => {
@@ -298,11 +297,7 @@ describe("SSE route — heartbeat", () => {
     reader.cancel();
 
     expect(chunks.length).toBeGreaterThan(0);
-    expect(
-      chunks.every(
-        (c) => c.includes(": heartbeat") && c.includes('{"type":"heartbeat"}'),
-      ),
-    ).toBe(true);
+    expect(chunks.every((c) => c === ": heartbeat\n\n")).toBe(true);
   });
 });
 

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -14,6 +14,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 const DECLARED_FLAG_ID = "email-channel";
 const DECLARED_FLAG_KEY = DECLARED_FLAG_ID;
+const SAFE_STORAGE_LIMITS_FLAG = "safe-storage-limits";
 
 const { isAssistantFeatureFlagEnabled, _setOverridesForTesting } =
   await import("../config/assistant-feature-flags.js");
@@ -62,6 +63,23 @@ describe("isAssistantFeatureFlagEnabled", () => {
     );
   });
 
+  test("safe-storage-limits defaults to disabled", () => {
+    const config = {} as any;
+
+    expect(
+      isAssistantFeatureFlagEnabled(SAFE_STORAGE_LIMITS_FLAG, config),
+    ).toBe(false);
+  });
+
+  test("safe-storage-limits respects explicit override", () => {
+    _setOverridesForTesting({ [SAFE_STORAGE_LIMITS_FLAG]: true });
+    const config = {} as any;
+
+    expect(
+      isAssistantFeatureFlagEnabled(SAFE_STORAGE_LIMITS_FLAG, config),
+    ).toBe(true);
+  });
+
   test("unknown flag defaults to true when no persisted override", () => {
     const config = {} as any;
 

package/src/__tests__/auto-analysis-end-to-end.test.ts

@@ -390,7 +390,12 @@ describe("auto-analysis batch trigger uses analysis.batchSize cadence", () => {
   const originalAnalysisBatch = TEST_CONFIG.analysis.batchSize;
 
   beforeEach(() => {
-    _setOverridesForTesting({ "auto-analyze": true });
+    // memory-v2-enabled gates v1 graph_extract enqueue; force off so
+    // these cadence tests can observe the v1 path.
+    _setOverridesForTesting({
+      "auto-analyze": true,
+      "memory-v2-enabled": false,
+    });
     TEST_CONFIG.memory.extraction.batchSize = 2;
     TEST_CONFIG.analysis.batchSize = 5;
   });
@@ -537,3 +542,59 @@ describe("auto-analysis batch trigger uses analysis.batchSize cadence", () => {
     expect(row.runAfter).toBeLessThanOrEqual(after + 1_000);
   });
 });
+
+// ─────────────────────────────────────────────────────────────────
+// Indexer v1/v2 mutual exclusion: when memory-v2-enabled is on AND
+// memory.v2.enabled is on, the v1 graph_extract enqueue is suppressed
+// (v2 reads from buffer.md, so v1 graph data is unread). When either
+// gate is off, v1 graph_extract fires.
+// ─────────────────────────────────────────────────────────────────
+
+describe("indexer v1/v2 mutual exclusion for graph_extract", () => {
+  // Force the v1 batch trigger so any enqueued row is observable.
+  const originalExtractionBatch = TEST_CONFIG.memory.extraction.batchSize;
+  const originalV2Enabled = TEST_CONFIG.memory.v2.enabled;
+
+  beforeEach(() => {
+    TEST_CONFIG.memory.extraction.batchSize = 1;
+  });
+
+  afterEach(() => {
+    TEST_CONFIG.memory.extraction.batchSize = originalExtractionBatch;
+    TEST_CONFIG.memory.v2.enabled = originalV2Enabled;
+  });
+
+  test("v2 active (flag on + config on) → graph_extract not enqueued", async () => {
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    TEST_CONFIG.memory.v2.enabled = true;
+
+    const source = createConversation("v2-active");
+    await indexMessages(source.id, 2);
+
+    expect(countJobsOfType("graph_extract", source.id)).toBe(0);
+  });
+
+  test("flag off → graph_extract enqueued", async () => {
+    _setOverridesForTesting({ "memory-v2-enabled": false });
+    TEST_CONFIG.memory.v2.enabled = true;
+
+    const source = createConversation("v2-flag-off");
+    await indexMessages(source.id, 2);
+
+    expect(countJobsOfType("graph_extract", source.id)).toBeGreaterThanOrEqual(
+      1,
+    );
+  });
+
+  test("config gate off (flag on) → graph_extract enqueued", async () => {
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    TEST_CONFIG.memory.v2.enabled = false;
+
+    const source = createConversation("v2-config-off");
+    await indexMessages(source.id, 2);
+
+    expect(countJobsOfType("graph_extract", source.id)).toBeGreaterThanOrEqual(
+      1,
+    );
+  });
+});

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-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("");
 }