@vellumai/assistant 0.7.1 → 0.7.3

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

@@ -1,7 +1,12 @@
-import { describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import type { AssistantEvent } from "../runtime/assistant-event.js";
-import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import {
+  AssistantEventHub,
+  broadcastMessage,
+  capabilityForMessageType,
+} from "../runtime/assistant-event-hub.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
 
 function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
   return {
@@ -350,3 +355,153 @@ describe("AssistantEventHub — re-entrancy / snapshot isolation", () => {
     expect(received).toHaveLength(1);
   });
 });
+
+// ── 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", () => {
+  test("two-segment domains map to their capability", () => {
+    expect(capabilityForMessageType("host_bash_request")).toBe("host_bash");
+    expect(capabilityForMessageType("host_bash_cancel")).toBe("host_bash");
+    expect(capabilityForMessageType("host_file_request")).toBe("host_file");
+    expect(capabilityForMessageType("host_cu_request")).toBe("host_cu");
+    expect(capabilityForMessageType("host_cu_cancel")).toBe("host_cu");
+    expect(capabilityForMessageType("host_browser_request")).toBe(
+      "host_browser",
+    );
+  });
+
+  test("host_transfer_* piggybacks on host_file capability", () => {
+    expect(capabilityForMessageType("host_transfer_request")).toBe("host_file");
+    expect(capabilityForMessageType("host_transfer_cancel")).toBe("host_file");
+  });
+
+  test("three-segment host_app_control routes to its own capability (longest-prefix wins)", () => {
+    expect(capabilityForMessageType("host_app_control_request")).toBe(
+      "host_app_control",
+    );
+    expect(capabilityForMessageType("host_app_control_cancel")).toBe(
+      "host_app_control",
+    );
+  });
+
+  test("non-host messages return undefined (broadcast)", () => {
+    expect(capabilityForMessageType("assistant_text_delta")).toBeUndefined();
+    expect(capabilityForMessageType("confirmation_request")).toBeUndefined();
+    expect(
+      capabilityForMessageType("conversation_list_invalidated"),
+    ).toBeUndefined();
+  });
+
+  test("unknown host_<domain>_* prefixes return undefined", () => {
+    expect(capabilityForMessageType("host_unknown_request")).toBeUndefined();
+  });
+});
+
+// ── broadcastMessage — pending interaction registration ─────────────────────
+//
+// Host proxy interactions (host_bash, host_cu, host_file, host_browser,
+// host_app_control, host_transfer) are registered in pendingInteractions by
+// the proxy itself (in its request() method), not by the event hub. This
+// avoids overwriting the RPC lifecycle state (rpcResolve/rpcReject/timer)
+// that the proxy stores alongside conversationId/kind.
+//
+// confirmation_request and secret_request are also NOT registered here — the
+// prompters (PermissionPrompter, SecretPrompter) self-register in their
+// prompt() methods, just like the host proxies. broadcastMessage is purely a
+// message-delivery mechanism; it has no registration side effects.
+
+describe("broadcastMessage — pending interaction registration", () => {
+  beforeEach(() => {
+    pendingInteractions.clear();
+  });
+
+  test("does NOT register confirmation_request — PermissionPrompter self-registers", () => {
+    broadcastMessage({
+      type: "confirmation_request",
+      requestId: "req-confirm-1",
+      conversationId: "conv-1",
+      toolName: "bash",
+      input: { command: "rm -rf /" },
+      riskLevel: "high",
+      executionTarget: "sandbox",
+      allowlistOptions: [],
+      scopeOptions: [],
+    } as never);
+
+    expect(pendingInteractions.get("req-confirm-1")).toBeUndefined();
+  });
+
+  test("does NOT register secret_request — SecretPrompter self-registers", () => {
+    broadcastMessage({
+      type: "secret_request",
+      requestId: "req-secret-1",
+      conversationId: "conv-1",
+      service: "github",
+      field: "token",
+    } as never);
+
+    expect(pendingInteractions.get("req-secret-1")).toBeUndefined();
+  });
+
+  test("does NOT register host proxy requests — proxies self-register", () => {
+    // host_bash, host_cu, host_file, host_browser, host_app_control, and
+    // host_transfer are registered by the proxy in request(), not here.
+    broadcastMessage({
+      type: "host_bash_request",
+      requestId: "req-bash-1",
+      conversationId: "conv-1",
+      command: "echo hi",
+      timeout_ms: 1000,
+    } as never);
+
+    expect(pendingInteractions.get("req-bash-1")).toBeUndefined();
+  });
+});

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

@@ -12,8 +12,9 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 // Test-scoped config state
 // ---------------------------------------------------------------------------
 
-const DECLARED_FLAG_ID = "sounds";
+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");
@@ -54,10 +55,29 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
   test("missing persisted value falls back to defaults registry defaultEnabled", () => {
     // No explicit config at all — should fall back to defaults registry
-    // which has defaultEnabled: true for sounds
+    // which has defaultEnabled: false for email-channel
     const config = {} as any;
 
-    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
+      false,
+    );
+  });
+
+  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", () => {
@@ -67,10 +87,12 @@ describe("isAssistantFeatureFlagEnabled", () => {
   });
 
   test("undeclared flag respects persisted override", () => {
-    _setOverridesForTesting({ browser: false });
+    _setOverridesForTesting({ "some-undeclared-flag": false });
     const config = {} as any;
 
-    expect(isAssistantFeatureFlagEnabled("browser", config)).toBe(false);
+    expect(isAssistantFeatureFlagEnabled("some-undeclared-flag", config)).toBe(
+      false,
+    );
   });
 });
 
@@ -87,7 +109,7 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
     ).toBe(false);
   });
 
-  test("enabled when no override set (registry default is true)", () => {
+  test("disabled when no override set (registry default is false)", () => {
     const config = {} as any;
 
     expect(
@@ -95,6 +117,6 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
         skillFlagKey({ featureFlag: DECLARED_FLAG_ID })!,
         config,
       ),
-    ).toBe(true);
+    ).toBe(false);
   });
 });

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-shell-host-bash.test.ts

@@ -74,7 +74,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
@@ -91,10 +90,16 @@ mock.module("../util/logger.js", () => ({
 // Mock HostBashProxy singleton — proxy delegation tests configure this.
 let mockProxyAvailable = false;
 let mockProxyRequestImpl: (
-  input: { command: string; working_dir?: string; timeout_seconds?: number; env?: Record<string, string> },
+  input: {
+    command: string;
+    working_dir?: string;
+    timeout_seconds?: number;
+    env?: Record<string, string>;
+  },
   conversationId: string,
   signal?: AbortSignal,
-) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+) => Promise<ToolExecutionResult> = () =>
+  Promise.resolve({ content: "", isError: false });
 
 mock.module("../daemon/host-bash-proxy.js", () => ({
   HostBashProxy: {
@@ -182,8 +187,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     const result = await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },
@@ -203,8 +207,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },
@@ -227,8 +230,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },
@@ -257,8 +259,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "bad-command", background: true },
@@ -280,8 +281,7 @@ describe("host_bash background mode — proxy path", () => {
     mockProxyRequestImpl = () =>
       Promise.reject(new Error("proxy transport error"));
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "echo fail", background: true },
@@ -305,8 +305,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     const result = await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },

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