@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/config-watcher-cleanup-throttle.test.ts

@@ -0,0 +1,339 @@
+/**
+ * Regression test for Gap D: ConfigWatcher.refreshConfigFromSources must
+ * reset the cleanup-scheduler throttle when memory.cleanup retention
+ * settings change. Without this, a user flipping their retention setting
+ * in the UI would have to wait up to 6 hours (the default
+ * enqueueIntervalMs) before the change takes effect, because
+ * maybeEnqueueScheduledCleanupJobs (in jobs-worker) early-returns while
+ * the throttle is still within its window.
+ *
+ * The shared throttle state lives in memory/cleanup-schedule-state.ts so
+ * that config-watcher can reset it without pulling jobs-worker's large
+ * transitive import graph into test modules. This test stubs the
+ * schedule-state module so calls from config-watcher can be counted
+ * directly.
+ *
+ * Two layers are exercised:
+ *   1. Pure helper test for cleanupSettingsChanged().
+ *   2. Integration test asserting ConfigWatcher.refreshConfigFromSources
+ *      invokes resetCleanupScheduleThrottle at the right times.
+ *
+ * memory-jobs-worker-backoff.test.ts covers the jobs-worker throttle
+ * semantics directly.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { MemoryCleanupConfig } from "../config/schemas/memory-lifecycle.js";
+import { cleanupSettingsChanged } from "../daemon/config-watcher.js";
+
+// ---------------------------------------------------------------------------
+// 1. Pure helper test — cleanupSettingsChanged
+// ---------------------------------------------------------------------------
+
+describe("cleanupSettingsChanged", () => {
+  const base: MemoryCleanupConfig = {
+    enabled: true,
+    enqueueIntervalMs: 6 * 60 * 60 * 1000,
+    supersededItemRetentionMs: 30 * 24 * 60 * 60 * 1000,
+    conversationRetentionDays: 0,
+    llmRequestLogRetentionMs: 1 * 24 * 60 * 60 * 1000,
+  };
+
+  test("returns false when either side is undefined", () => {
+    expect(cleanupSettingsChanged(undefined, base)).toBe(false);
+    expect(cleanupSettingsChanged(base, undefined)).toBe(false);
+    expect(cleanupSettingsChanged(undefined, undefined)).toBe(false);
+  });
+
+  test("returns false when all fields are equal", () => {
+    expect(cleanupSettingsChanged(base, { ...base })).toBe(false);
+  });
+
+  test("returns true when llmRequestLogRetentionMs changes", () => {
+    expect(
+      cleanupSettingsChanged(base, {
+        ...base,
+        llmRequestLogRetentionMs: 7 * 24 * 60 * 60 * 1000,
+      }),
+    ).toBe(true);
+  });
+
+  test("returns true when conversationRetentionDays changes", () => {
+    expect(
+      cleanupSettingsChanged(base, {
+        ...base,
+        conversationRetentionDays: 30,
+      }),
+    ).toBe(true);
+  });
+
+  test("returns true when cleanup.enabled toggles", () => {
+    expect(cleanupSettingsChanged(base, { ...base, enabled: false })).toBe(
+      true,
+    );
+  });
+
+  test("returns false when only non-tracked fields change", () => {
+    // enqueueIntervalMs and supersededItemRetentionMs are intentionally
+    // excluded — they are daemon tunables, not user-facing UI settings.
+    expect(
+      cleanupSettingsChanged(base, {
+        ...base,
+        enqueueIntervalMs: 1_000,
+        supersededItemRetentionMs: 0,
+      }),
+    ).toBe(false);
+  });
+
+  test("returns true when llmRequestLogRetentionMs changes from number to null", () => {
+    expect(
+      cleanupSettingsChanged(base, {
+        ...base,
+        llmRequestLogRetentionMs: null,
+      }),
+    ).toBe(true);
+  });
+
+  test("returns true when llmRequestLogRetentionMs changes from null to number", () => {
+    const nullBase = { ...base, llmRequestLogRetentionMs: null };
+    expect(
+      cleanupSettingsChanged(nullBase, {
+        ...nullBase,
+        llmRequestLogRetentionMs: 86_400_000,
+      }),
+    ).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 2. Integration test — ConfigWatcher calls resetCleanupScheduleThrottle
+// ---------------------------------------------------------------------------
+
+// Track calls from config-watcher into the (mocked) cleanup-schedule-state.
+let resetCleanupScheduleThrottleCalls = 0;
+
+mock.module("../memory/cleanup-schedule-state.js", () => ({
+  resetCleanupScheduleThrottle: () => {
+    resetCleanupScheduleThrottleCalls++;
+  },
+  getLastScheduledCleanupEnqueueMs: () => 0,
+  markScheduledCleanupEnqueued: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (v: string) => v,
+}));
+
+// Simulate a config-cache layer: `diskConfig` is the on-disk value,
+// `cachedConfig` is what getConfig() returns until invalidateConfigCache()
+// is called. This matches the production behavior where getConfig() returns
+// a memoized value that only refreshes after explicit invalidation. Tests
+// mutate `diskConfig` to simulate a user writing a new config.json.
+interface TestConfig {
+  memory: {
+    enabled: boolean;
+    cleanup: {
+      enabled: boolean;
+      enqueueIntervalMs: number;
+      supersededItemRetentionMs: number;
+      conversationRetentionDays: number;
+      llmRequestLogRetentionMs: number | null;
+    };
+  };
+}
+
+let diskConfig: TestConfig = makeConfig();
+let cachedConfig: TestConfig | null = null;
+
+function makeConfig(
+  overrides: Partial<TestConfig["memory"]["cleanup"]> = {},
+): TestConfig {
+  return {
+    memory: {
+      enabled: true,
+      cleanup: {
+        enabled: true,
+        enqueueIntervalMs: 6 * 60 * 60 * 1000,
+        supersededItemRetentionMs: 30 * 24 * 60 * 60 * 1000,
+        conversationRetentionDays: 0,
+        llmRequestLogRetentionMs: 1 * 24 * 60 * 60 * 1000,
+        ...overrides,
+      },
+    },
+  };
+}
+
+function primeConfigCache(): void {
+  cachedConfig = diskConfig;
+}
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => {
+    if (!cachedConfig) {
+      cachedConfig = diskConfig;
+    }
+    return cachedConfig;
+  },
+  invalidateConfigCache: () => {
+    cachedConfig = null;
+  },
+}));
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  clearFeatureFlagOverridesCache: () => {},
+}));
+
+mock.module("../memory/embedding-backend.js", () => ({
+  clearEmbeddingBackendCache: () => {},
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  clearCache: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  initializeProviders: async () => {},
+}));
+
+mock.module("../signals/bash.js", () => ({
+  handleBashSignal: () => {},
+}));
+
+mock.module("../signals/cancel.js", () => ({
+  handleCancelSignal: () => {},
+}));
+
+mock.module("../signals/conversation-undo.js", () => ({
+  handleConversationUndoSignal: () => {},
+}));
+
+mock.module("../signals/emit-event.js", () => ({
+  handleEmitEventSignal: () => {},
+}));
+
+mock.module("../signals/mcp-reload.js", () => ({
+  handleMcpReloadSignal: () => {},
+}));
+
+mock.module("../signals/shotgun.js", () => ({
+  handleShotgunSignal: () => {},
+}));
+
+mock.module("../signals/user-message.js", () => ({
+  handleUserMessageSignal: () => {},
+}));
+
+// Import ConfigWatcher AFTER mocks are declared.
+const { ConfigWatcher } = await import("../daemon/config-watcher.js");
+
+describe("ConfigWatcher.refreshConfigFromSources cleanup throttle reset", () => {
+  beforeEach(() => {
+    resetCleanupScheduleThrottleCalls = 0;
+    diskConfig = makeConfig();
+    cachedConfig = null;
+  });
+
+  test("resets throttle when llmRequestLogRetentionMs changes", async () => {
+    const watcher = new ConfigWatcher();
+    // Seed the initial fingerprint and prime the cache so refreshConfigFromSources
+    // can compare the prev (cached) and next (fresh-from-disk) snapshots.
+    watcher.initFingerprint(diskConfig as never);
+    primeConfigCache();
+
+    // Simulate user changing retention from 1d to 7d via the UI — this
+    // writes to disk and is ONLY visible to getConfig() after a cache
+    // invalidation.
+    diskConfig = makeConfig({
+      llmRequestLogRetentionMs: 7 * 24 * 60 * 60 * 1000,
+    });
+
+    const changed = await watcher.refreshConfigFromSources();
+    expect(changed).toBe(true);
+    expect(resetCleanupScheduleThrottleCalls).toBe(1);
+  });
+
+  test("does NOT reset throttle when config is identical (no fingerprint change)", async () => {
+    const watcher = new ConfigWatcher();
+    watcher.initFingerprint(diskConfig as never);
+    primeConfigCache();
+
+    // No change: diskConfig is the same value.
+    const changed = await watcher.refreshConfigFromSources();
+    expect(changed).toBe(false);
+    expect(resetCleanupScheduleThrottleCalls).toBe(0);
+  });
+
+  test("does NOT reset throttle when an unrelated cleanup field changes", async () => {
+    const watcher = new ConfigWatcher();
+    watcher.initFingerprint(diskConfig as never);
+    primeConfigCache();
+
+    // enqueueIntervalMs is a daemon tunable, not a user-facing setting.
+    // The fingerprint changes but the tracked cleanup retention fields
+    // don't, so the throttle should NOT be reset.
+    diskConfig = makeConfig({ enqueueIntervalMs: 30_000 });
+
+    const changed = await watcher.refreshConfigFromSources();
+    expect(changed).toBe(true);
+    expect(resetCleanupScheduleThrottleCalls).toBe(0);
+  });
+
+  test("resets throttle when conversationRetentionDays changes", async () => {
+    const watcher = new ConfigWatcher();
+    watcher.initFingerprint(diskConfig as never);
+    primeConfigCache();
+
+    diskConfig = makeConfig({ conversationRetentionDays: 30 });
+
+    const changed = await watcher.refreshConfigFromSources();
+    expect(changed).toBe(true);
+    expect(resetCleanupScheduleThrottleCalls).toBe(1);
+  });
+
+  test("resets throttle when llmRequestLogRetentionMs changes from number to null", async () => {
+    const watcher = new ConfigWatcher();
+    watcher.initFingerprint(diskConfig as never);
+    primeConfigCache();
+
+    diskConfig = makeConfig({ llmRequestLogRetentionMs: null });
+
+    const changed = await watcher.refreshConfigFromSources();
+    expect(changed).toBe(true);
+    expect(resetCleanupScheduleThrottleCalls).toBe(1);
+  });
+
+  test("end-to-end: retention change via watcher triggers repeated resets", async () => {
+    // This is the user-facing regression guarantee: each time the user
+    // changes retention via the UI, refreshConfigFromSources calls the
+    // cleanup-schedule-state throttle reset so the next scheduler tick
+    // re-evaluates without waiting out the 6-hour window.
+    //
+    // Because cleanup-schedule-state is mocked here, we verify the
+    // CONTRACT (resetCleanupScheduleThrottle is called) rather than the
+    // internal state. memory-jobs-worker-backoff tests cover the
+    // jobs-worker throttle semantics independently.
+    const watcher = new ConfigWatcher();
+    watcher.initFingerprint(diskConfig as never);
+    primeConfigCache();
+
+    expect(resetCleanupScheduleThrottleCalls).toBe(0);
+
+    diskConfig = makeConfig({
+      llmRequestLogRetentionMs: 3 * 24 * 60 * 60 * 1000,
+    });
+    await watcher.refreshConfigFromSources();
+    expect(resetCleanupScheduleThrottleCalls).toBe(1);
+
+    // Changing retention again should trigger another reset, confirming
+    // the wiring holds up for repeated edits.
+    diskConfig = makeConfig({
+      llmRequestLogRetentionMs: 14 * 24 * 60 * 60 * 1000,
+    });
+    await watcher.refreshConfigFromSources();
+    expect(resetCleanupScheduleThrottleCalls).toBe(2);
+  });
+});

package/src/__tests__/config-watcher.test.ts

@@ -1,4 +1,5 @@
 import { mkdirSync } from "node:fs";
+import { join } from "node:path";
 import {
   afterEach,
   beforeAll,
@@ -156,14 +157,6 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(1);
   });
 
-  test("USER.md change triggers onConversationEvict", async () => {
-    watcher.start(onConversationEvict);
-    simulateFileChange(WORKSPACE_DIR, "USER.md");
-
-    await new Promise((r) => setTimeout(r, 300));
-    expect(evictCallCount).toBe(1);
-  });
-
   test("UPDATES.md change triggers onConversationEvict", async () => {
     watcher.start(onConversationEvict);
     simulateFileChange(WORKSPACE_DIR, "UPDATES.md");
@@ -275,6 +268,48 @@ describe("ConfigWatcher watcher lifecycle", () => {
   });
 });
 
+describe("ConfigWatcher users directory watcher", () => {
+  const USERS_DIR = join(WORKSPACE_DIR, "users");
+
+  test("editing users/<slug>.md triggers onConversationEvict", async () => {
+    watcher.start(onConversationEvict);
+    simulateFileChange(USERS_DIR, "alice.md");
+
+    await new Promise((r) => setTimeout(r, 300));
+    expect(evictCallCount).toBe(1);
+  });
+
+  test("non-.md files in users/ do NOT trigger eviction", async () => {
+    watcher.start(onConversationEvict);
+    simulateFileChange(USERS_DIR, "alice.json");
+    simulateFileChange(USERS_DIR, "notes.txt");
+    simulateFileChange(USERS_DIR, "README");
+
+    await new Promise((r) => setTimeout(r, 300));
+    expect(evictCallCount).toBe(0);
+  });
+
+  test("null filename in users/ does not trigger eviction", async () => {
+    watcher.start(onConversationEvict);
+    const usersWatcher = findWatcher(USERS_DIR);
+    expect(usersWatcher).toBeDefined();
+    usersWatcher!.callback("change", null);
+
+    await new Promise((r) => setTimeout(r, 300));
+    expect(evictCallCount).toBe(0);
+  });
+
+  test("multiple rapid changes to the same persona file are debounced", async () => {
+    watcher.start(onConversationEvict);
+    simulateFileChange(USERS_DIR, "bob.md");
+    simulateFileChange(USERS_DIR, "bob.md");
+    simulateFileChange(USERS_DIR, "bob.md");
+
+    await new Promise((r) => setTimeout(r, 300));
+    expect(evictCallCount).toBe(1);
+  });
+});
+
 describe("ConfigWatcher fingerprinting", () => {
   test("configFingerprint returns JSON string of config", () => {
     const config = { foo: "bar" } as any;

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -10,6 +10,8 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -133,6 +135,7 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     resetTables();
     emittedSignals.length = 0;
     mockOnConversationCreatedCallbacks.length = 0;
+    _setOverridesForTesting({});
   });
 
   test("emits guardian.question for trusted-contact sessions", () => {
@@ -223,6 +226,26 @@ describe("bridgeConfirmationRequestToGuardian", () => {
     expect(emittedSignals).toHaveLength(0);
   });
 
+  test("skips trusted-contact bridging entirely under permission-controls-v2", () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+
+    const canonicalRequest = makeCanonicalRequest();
+    const trustContext = makeTrustedContactContext();
+
+    const result = bridgeConfirmationRequestToGuardian({
+      canonicalRequest,
+      trustContext,
+      conversationId: "conv-1",
+      toolName: "bash",
+    });
+
+    expect("skipped" in result && result.skipped).toBe(true);
+    if ("skipped" in result) {
+      expect(result.reason).toBe("v2_model_mediated");
+    }
+    expect(emittedSignals).toHaveLength(0);
+  });
+
   test("skips when no guardian binding exists for channel", () => {
     const canonicalRequest = makeCanonicalRequest({ sourceChannel: "phone" });
     const trustContext = makeTrustedContactContext({