@vellumai/assistant 0.7.1 → 0.7.3

package/src/credential-execution/process-manager.ts

@@ -12,12 +12,6 @@
  * creates a socket-based CesTransport. The CES sidecar manages its own
  * lifecycle; the process manager only manages the transport connection.
  *
- * Feature-flag gate: Managed sidecar mode is controlled by the
- * `ces-managed-sidecar` feature flag (checked via the required
- * AssistantConfig). When the flag is off, the process manager skips
- * managed discovery even in containerized environments, ensuring
- * rollback safety.
- *
  * Managed env contract:
  * - CES_BOOTSTRAP_SOCKET  — Path to the bootstrap Unix socket (shared emptyDir)
  * - /assistant-data-ro     — Assistant data mounted read-only into the CES sidecar
@@ -42,7 +36,6 @@ import {
   type LocalSourceDiscoverySuccess,
   type ManagedDiscoverySuccess,
 } from "./executable-discovery.js";
-import { isCesManagedSidecarEnabled } from "./feature-gates.js";
 
 const log = getLogger("ces-process-manager");
 
@@ -71,10 +64,8 @@ export const CES_PRIVATE_DATA_DIR = "/ces-data";
 
 export interface CesProcessManagerConfig {
   /**
-   * Assistant configuration for feature-flag checks.
-   * The managed sidecar path is gated behind the `ces-managed-sidecar`
-   * feature flag via this config.  When omitted (e.g. CLI / admin
-   * callers), managed mode is allowed unconditionally.
+   * Assistant configuration.
+   * Reserved for future feature-flag checks or config-driven behavior.
    */
   assistantConfig?: AssistantConfig;
 }
@@ -88,10 +79,6 @@ export interface CesProcessManager {
    * Start the CES process (local) or connect to the sidecar (managed).
    * Returns a CesTransport ready for use with createCesClient().
    *
-   * When the `ces-managed-sidecar` feature flag is off, managed mode
-   * is skipped even in containerized environments — the process manager
-   * falls back to local discovery.
-   *
    * Throws if CES is unavailable.
    */
   start(): Promise<CesTransport>;
@@ -118,7 +105,7 @@ export interface CesProcessManager {
 // ---------------------------------------------------------------------------
 
 export function createCesProcessManager(
-  config: CesProcessManagerConfig,
+  _config: CesProcessManagerConfig,
 ): CesProcessManager {
   let childProcess: Subprocess | null = null;
   let managedSocket: Socket | null = null;
@@ -131,31 +118,15 @@ export function createCesProcessManager(
         throw new Error("CES process manager is already running");
       }
 
-      // Feature-flag gate: when the managed sidecar flag is off, skip
-      // managed discovery entirely. This ensures rollback safety —
-      // disabling the flag leaves existing non-agent platform consumers
-      // intact.
-      const managedAllowed = config.assistantConfig
-        ? isCesManagedSidecarEnabled(config.assistantConfig)
-        : true; // No config → allow managed mode unconditionally (CLI/admin callers)
-
-      if (managedAllowed) {
-        discoveryResult = await discoverCes();
-        if (discoveryResult.mode === "unavailable") {
-          // The managed sidecar bootstrap socket is not present — this happens
-          // when the flag is enabled by default but the instance pre-dates the
-          // socket volume mount (e.g. existing Docker configs without the
-          // ces-bootstrap volume). Warn and fall back to local discovery so
-          // these deployments don't fail on upgrade.
-          log.warn(
-            { reason: discoveryResult.reason },
-            "CES managed sidecar bootstrap socket unavailable — falling back to local CES discovery",
-          );
-          discoveryResult = discoverLocalCes();
-        }
-      } else {
-        log.info(
-          "CES managed sidecar feature flag is off — skipping managed discovery, falling back to local",
+      discoveryResult = await discoverCes();
+      if (discoveryResult.mode === "unavailable") {
+        // The managed sidecar bootstrap socket is not present — this happens
+        // when the instance pre-dates the socket volume mount (e.g. existing
+        // Docker configs without the ces-bootstrap volume). Warn and fall
+        // back to local discovery so these deployments don't fail on upgrade.
+        log.warn(
+          { reason: discoveryResult.reason },
+          "CES managed sidecar bootstrap socket unavailable — falling back to local CES discovery",
         );
         discoveryResult = discoverLocalCes();
       }

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -18,17 +18,45 @@
  * first and is authoritative for structural support, so host_bash and
  * host_file_* are filtered out for chrome-extension regardless of the
  * hasNoClient flag.
+ *
+ * Cross-client exception: tools whose capabilities are in
+ * CROSS_CLIENT_EXPOSED_CAPABILITIES (host_bash, host_file) are allowed for
+ * non-host-proxy interfaces (e.g. "web") when at least one capable client
+ * is connected via the event hub. host_browser is excluded (chrome-extension
+ * is its own executor; web turns have no CDP target model).
  */
 
-import { describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Module-level mocks ─────────────────────────────────────────────
+
+// Control how many capable clients the hub reports per capability.
+const mockClientCountByCapability = new Map<string, number>();
 
-import type { SkillProjectionCache } from "../conversation-skill-tools.js";
-import {
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    listClientsByCapability: (cap: string) => {
+      const count = mockClientCountByCapability.get(cap) ?? 0;
+      return Array.from({ length: count }, (_, i) => ({
+        clientId: `mock-${cap}-client-${i}`,
+        capabilities: [cap],
+      }));
+    },
+  },
+  broadcastMessage: () => {},
+}));
+
+// Dynamic imports after mock.module calls so the stubs take effect
+// before the modules under test are loaded.
+const {
   HOST_TOOL_NAMES,
   HOST_TOOL_TO_CAPABILITY,
   isToolActiveForContext,
-  type SkillProjectionContext,
-} from "../conversation-tool-setup.js";
+} = await import("../conversation-tool-setup.js");
+type SkillProjectionContext =
+  import("../conversation-tool-setup.js").SkillProjectionContext;
+type SkillProjectionCache =
+  import("../conversation-skill-tools.js").SkillProjectionCache;
 
 function makeCtx(
   overrides: Partial<SkillProjectionContext> = {},
@@ -42,6 +70,10 @@ function makeCtx(
   };
 }
 
+beforeEach(() => {
+  mockClientCountByCapability.clear();
+});
+
 describe("isToolActiveForContext — host tool capability gating", () => {
   // macOS transport: SSE-based interactive approval required.
   test("host_bash is active for macOS with a connected client", () => {
@@ -176,6 +208,156 @@ describe("isToolActiveForContext — host tool capability gating", () => {
   });
 });
 
+describe("isToolActiveForContext — cross-client exception (Phase 1: host_bash)", () => {
+  test("host_bash is active for web transport when a host_bash-capable client is connected", () => {
+    // Cross-client path: a web turn should see host_bash when a macOS client
+    // with host_bash capability is connected via the event hub.
+    mockClientCountByCapability.set("host_bash", 1);
+    expect(
+      isToolActiveForContext(
+        "host_bash",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("host_bash is NOT active for web transport when no capable client is connected", () => {
+    // No cross-client fallback: hub has no host_bash-capable subscribers.
+    mockClientCountByCapability.set("host_bash", 0);
+    expect(
+      isToolActiveForContext(
+        "host_bash",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_file_read is NOT active for web transport when only a host_bash client is connected", () => {
+    // The cross-client exception is per-capability: a host_bash-capable
+    // client in the hub does not satisfy host_file's exposure check, since
+    // listClientsByCapability is queried with the tool's actual capability.
+    mockClientCountByCapability.set("host_bash", 1);
+    expect(
+      isToolActiveForContext(
+        "host_file_read",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_bash for macos transport is unaffected by the cross-client exception", () => {
+    // macos natively supports host_bash via host proxy — the supportsHostProxy
+    // check passes, so the cross-client branch is never reached.
+    mockClientCountByCapability.set("host_bash", 0);
+    expect(
+      isToolActiveForContext(
+        "host_bash",
+        makeCtx({ hasNoClient: false, transportInterface: "macos" }),
+      ),
+    ).toBe(true);
+  });
+
+  test("host_bash for macos with no client is still denied (security invariant unaffected)", () => {
+    // Even with a capable client in the hub, the macos SSE path takes
+    // precedence — it passes the supportsHostProxy check, bypasses the
+    // cross-client branch, and reaches the hasNoClient gate.
+    mockClientCountByCapability.set("host_bash", 1);
+    expect(
+      isToolActiveForContext(
+        "host_bash",
+        makeCtx({ hasNoClient: true, transportInterface: "macos" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_bash is NOT active for chrome-extension even when a capable client is connected", () => {
+    // Security boundary: chrome-extension only gets host_browser. The
+    // cross-client exception explicitly excludes chrome-extension transport
+    // regardless of how many host_bash-capable clients are in the hub.
+    mockClientCountByCapability.set("host_bash", 1);
+    expect(
+      isToolActiveForContext(
+        "host_bash",
+        makeCtx({ hasNoClient: false, transportInterface: "chrome-extension" }),
+      ),
+    ).toBe(false);
+  });
+
+  test("host_bash is NOT active for web transport when hasNoClient is true (no approval UI)", () => {
+    // hasNoClient gate: no interactive approval UI available for this turn.
+    // Cross-client exception must not bypass this gate.
+    mockClientCountByCapability.set("host_bash", 1);
+    expect(
+      isToolActiveForContext(
+        "host_bash",
+        makeCtx({ hasNoClient: true, transportInterface: "web" }),
+      ),
+    ).toBe(false);
+  });
+});
+
+describe("isToolActiveForContext — cross-client exposure for host_file_*", () => {
+  const HOST_FILE_TOOLS = [
+    "host_file_read",
+    "host_file_write",
+    "host_file_edit",
+    "host_file_transfer",
+  ] as const;
+
+  for (const tool of HOST_FILE_TOOLS) {
+    test(`${tool} is exposed for web transport when a host_file client is connected`, () => {
+      mockClientCountByCapability.set("host_file", 1);
+      expect(
+        isToolActiveForContext(
+          tool,
+          makeCtx({ hasNoClient: false, transportInterface: "web" }),
+        ),
+      ).toBe(true);
+    });
+
+    test(`${tool} is NOT exposed for web when no host_file client is connected`, () => {
+      mockClientCountByCapability.set("host_file", 0);
+      expect(
+        isToolActiveForContext(
+          tool,
+          makeCtx({ hasNoClient: false, transportInterface: "web" }),
+        ),
+      ).toBe(false);
+    });
+
+    test(`${tool} is NOT exposed for chrome-extension (security boundary)`, () => {
+      mockClientCountByCapability.set("host_file", 1);
+      expect(
+        isToolActiveForContext(
+          tool,
+          makeCtx({ hasNoClient: true, transportInterface: "chrome-extension" }),
+        ),
+      ).toBe(false);
+    });
+
+    test(`${tool} is NOT exposed when hasNoClient is true (no approval UI)`, () => {
+      mockClientCountByCapability.set("host_file", 1);
+      expect(
+        isToolActiveForContext(
+          tool,
+          makeCtx({ hasNoClient: true, transportInterface: "web" }),
+        ),
+      ).toBe(false);
+    });
+  }
+
+  test("listClientsByCapability is queried with the actual capability, not host_bash (regression guard for D5 latent bug)", () => {
+    mockClientCountByCapability.set("host_bash", 0);
+    mockClientCountByCapability.set("host_file", 1);
+    expect(
+      isToolActiveForContext(
+        "host_file_transfer",
+        makeCtx({ hasNoClient: false, transportInterface: "web" }),
+      ),
+    ).toBe(true);
+  });
+});
+
 describe("HOST_TOOL_NAMES derivation", () => {
   test("HOST_TOOL_NAMES is derived from HOST_TOOL_TO_CAPABILITY", () => {
     // Sanity check: every tool in the names set has a capability mapping.

package/src/daemon/assistant-attachments.ts

@@ -125,7 +125,7 @@ export function classifyKind(mimeType: string): "image" | "video" | "document" {
 // Validation / cap enforcement
 // ---------------------------------------------------------------------------
 
-export interface ValidatedDrafts {
+interface ValidatedDrafts {
   accepted: AssistantAttachmentDraft[];
   warnings: string[];
 }
@@ -171,13 +171,13 @@ export interface DirectiveRequest {
   mimeType: string | undefined;
 }
 
-export interface DirectiveParseResult {
+interface DirectiveParseResult {
   cleanText: string;
   directiveRequests: DirectiveRequest[];
   parseWarnings: string[];
 }
 
-export interface DirectiveDisplayDrainResult {
+interface DirectiveDisplayDrainResult {
   emitText: string;
   bufferedRemainder: string;
 }
@@ -362,7 +362,7 @@ export function drainDirectiveDisplayBuffer(
 // Sandbox file resolution
 // ---------------------------------------------------------------------------
 
-export interface ResolveResult {
+interface ResolveResult {
   draft: AssistantAttachmentDraft | null;
   warning: string | null;
 }

package/src/daemon/bootstrap-turn-cleanup.ts

@@ -0,0 +1,45 @@
+import { getMessages, type MessageRow } from "../memory/conversation-crud.js";
+import { cleanupBootstrapFiles } from "../prompts/bootstrap-cleanup.js";
+import { getLogger } from "../util/logger.js";
+
+export const BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD = 4;
+
+const log = getLogger("bootstrap-turn-cleanup");
+
+function isWakeUpGreetingMessage(content: string): boolean {
+  return content.toLowerCase().includes("wake up, my friend");
+}
+
+export function countBootstrapUserTurns(
+  messages: Pick<MessageRow, "role" | "content">[],
+): number {
+  return messages.filter(
+    (message) =>
+      message.role === "user" && !isWakeUpGreetingMessage(message.content),
+  ).length;
+}
+
+export function shouldCleanupBootstrapAfterTurn(
+  messages: Pick<MessageRow, "role" | "content">[],
+  threshold = BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD,
+): boolean {
+  return countBootstrapUserTurns(messages) >= threshold;
+}
+
+export function cleanupBootstrapAfterTurnThreshold(
+  conversationId: string,
+): boolean {
+  let messages: MessageRow[];
+  try {
+    messages = getMessages(conversationId);
+  } catch (err) {
+    log.warn({ err, conversationId }, "Failed to inspect bootstrap turn count");
+    return false;
+  }
+
+  if (!shouldCleanupBootstrapAfterTurn(messages)) return false;
+
+  return cleanupBootstrapFiles(
+    `first conversation reached ${BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD} user turns`,
+  );
+}

package/src/daemon/config-watcher.ts

@@ -8,7 +8,9 @@ import {
   type FSWatcher,
   mkdirSync,
   readdirSync,
+  unwatchFile,
   watch,
+  watchFile,
 } from "node:fs";
 import { join } from "node:path";
 
@@ -17,11 +19,9 @@ import type { MemoryCleanupConfig } from "../config/schemas/memory-lifecycle.js"
 import { resetCleanupScheduleThrottle } from "../memory/cleanup-schedule-state.js";
 import { clearEmbeddingBackendCache } from "../memory/embedding-backend.js";
 import { initializeProviders } from "../providers/registry.js";
-import { handleBashSignal } from "../signals/bash.js";
 import { handleCancelSignal } from "../signals/cancel.js";
 import { handleConversationUndoSignal } from "../signals/conversation-undo.js";
 import { handleEmitEventSignal } from "../signals/emit-event.js";
-import { handleMcpReloadSignal } from "../signals/mcp-reload.js";
 import { handleUserMessageSignal } from "../signals/user-message.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
@@ -33,6 +33,7 @@ import {
   getWorkspaceDir,
   getWorkspaceSkillsDir,
 } from "../util/platform.js";
+import { reloadMcpServers } from "./mcp-reload-service.js";
 
 const log = getLogger("config-watcher");
 
@@ -47,19 +48,44 @@ function attachWatcherErrorHandler(watcher: FSWatcher, dir: string): void {
   });
 }
 
+/**
+ * Poll interval for `fs.watchFile()`. Use the stat-polling watcher
+ * because Bun's per-file `fs.watch()` doesn't detect renames on Linux
+ * (seemingly works on macOS). See https://github.com/oven-sh/bun/issues/15010.
+ */
+const WATCH_FILE_POLL_MS = 2_000;
+
 export class ConfigWatcher {
   private watchers: FSWatcher[] = [];
-  private debounceTimers = new DebouncerMap({
-    defaultDelayMs: 200,
-    maxEntries: 1000,
-    protectedKeyPrefix: "__",
-  });
+  private watchedFiles: Set<string> = new Set();
+  private stopped = false;
+  private debounceTimers: DebouncerMap;
   private suppressReload = false;
   lastFingerprint = "";
+  private lastConfig: ReturnType<typeof getConfig> | null = null;
   private lastRefreshTime = 0;
 
   static readonly REFRESH_INTERVAL_MS = 30_000;
 
+  /**
+   * @param pollIntervalMs Per-file stat poll interval (passed to
+   *   `fs.watchFile`). Default `WATCH_FILE_POLL_MS` (2s); tests pass a
+   *   smaller value for fast turnaround.
+   * @param debounceMs Debounce window applied to any detected file
+   *   change before invoking its handler. Default 200ms; tests pass a
+   *   smaller value to avoid sleeping unnecessarily.
+   */
+  constructor(
+    private readonly pollIntervalMs: number = WATCH_FILE_POLL_MS,
+    debounceMs = 200,
+  ) {
+    this.debounceTimers = new DebouncerMap({
+      defaultDelayMs: debounceMs,
+      maxEntries: 1000,
+      protectedKeyPrefix: "__",
+    });
+  }
+
   /** Expose the debounce timers so handlers can schedule debounced work. */
   get timers(): DebouncerMap {
     return this.debounceTimers;
@@ -88,12 +114,15 @@ export class ConfigWatcher {
 
   /** Initialize the config fingerprint (call after first config load). */
   initFingerprint(config: ReturnType<typeof getConfig>): void {
+    this.lastConfig = config;
     this.lastFingerprint = this.configFingerprint(config);
   }
 
   /** Update the fingerprint to match the current config. */
   updateFingerprint(): void {
-    this.lastFingerprint = this.configFingerprint(getConfig());
+    const config = getConfig();
+    this.lastConfig = config;
+    this.lastFingerprint = this.configFingerprint(config);
     this.lastRefreshTime = Date.now();
   }
 
@@ -103,7 +132,7 @@ export class ConfigWatcher {
    * Returns true if config actually changed.
    */
   async refreshConfigFromSources(): Promise<boolean> {
-    const prevCleanup = safeGetCleanupConfig();
+    const prevCleanup = this.lastConfig?.memory?.cleanup;
     invalidateConfigCache();
     const config = getConfig();
     const fingerprint = this.configFingerprint(config);
@@ -120,6 +149,7 @@ export class ConfigWatcher {
     }
     const isFirstInit = this.lastFingerprint === "";
     await initializeProviders(config);
+    this.lastConfig = config;
     this.lastFingerprint = fingerprint;
     return !isFirstInit;
   }
@@ -136,22 +166,29 @@ export class ConfigWatcher {
     onAvatarChanged?: () => void,
     onConfigChanged?: () => void,
   ): void {
+    // Reset the stopped flag so a stop()→start() cycle on the same
+    // instance resumes hot-reload instead of silently bailing in every
+    // watchFile callback. This matters because getConfigWatcher() is a
+    // module-level singleton — a daemon restart path that reuses it
+    // would otherwise be permanently mute.
+    this.stopped = false;
     const workspaceDir = getWorkspaceDir();
 
     const workspaceHandlers: Record<string, () => void> = {
       "config.json": async () => {
         if (this.suppressReload) return;
         try {
-          const prevConfig = getConfig();
-          const prevMcpFingerprint = JSON.stringify(prevConfig.mcp ?? {});
+          const prevMcpFingerprint = JSON.stringify(this.lastConfig?.mcp ?? {});
           const changed = await this.refreshConfigFromSources();
           if (changed) {
             onConversationEvict();
             onConfigChanged?.();
-            const newConfig = getConfig();
+            const newConfig = this.lastConfig ?? getConfig();
             const newMcpFingerprint = JSON.stringify(newConfig.mcp ?? {});
             if (newMcpFingerprint !== prevMcpFingerprint) {
-              handleMcpReloadSignal();
+              reloadMcpServers().catch((err: unknown) => {
+                log.error({ err }, "MCP reload after config change failed");
+              });
             }
           }
         } catch (err) {
@@ -168,37 +205,11 @@ export class ConfigWatcher {
       },
     };
 
-    const watchDir = (
-      dir: string,
-      handlers: Record<string, () => void>,
-      label: string,
-    ): void => {
-      try {
-        const watcher = watch(dir, (_eventType, filename) => {
-          if (!filename) return;
-          const file = String(filename);
-          if (!handlers[file]) return;
-          this.debounceTimers.schedule(`file:${file}`, () => {
-            log.info({ file }, "File changed, reloading");
-            handlers[file]();
-          });
-        });
-        attachWatcherErrorHandler(watcher, dir);
-        this.watchers.push(watcher);
-        log.info({ dir }, `Watching ${label}`);
-      } catch (err) {
-        log.warn(
-          { err, dir },
-          `Failed to watch ${label}. Hot-reload will be unavailable.`,
-        );
-      }
-    };
-
-    watchDir(
-      workspaceDir,
-      workspaceHandlers,
-      "workspace directory for config/prompt changes",
-    );
+    // Per-file watches; don't watch the workspace directory itself because
+    // it contains socket files.
+    for (const [filename, handler] of Object.entries(workspaceHandlers)) {
+      this.watchFile(join(workspaceDir, filename), handler, filename);
+    }
 
     if (onSoundsConfigChanged) {
       this.startSoundsWatcher(onSoundsConfigChanged);
@@ -213,13 +224,46 @@ export class ConfigWatcher {
   }
 
   stop(): void {
+    this.stopped = true;
     this.debounceTimers.cancelAll();
+    for (const filePath of this.watchedFiles) {
+      unwatchFile(filePath);
+    }
+    this.watchedFiles.clear();
     for (const watcher of this.watchers) {
       watcher.close();
     }
     this.watchers = [];
   }
 
+  private watchFile(
+    filePath: string,
+    handler: () => void,
+    label: string,
+  ): void {
+    // Match the defensive pattern used by every other startXWatcher in
+    // this file: log the failure and continue. Per AGENTS.md, the daemon
+    // must never block startup — a watchFile() throw on some platform
+    // edge case must not propagate up to DaemonServer.start().
+    try {
+      watchFile(filePath, { interval: this.pollIntervalMs }, (curr, prev) => {
+        if (this.stopped) return;
+        if (curr.ino === prev.ino && curr.mtimeMs === prev.mtimeMs) return;
+        this.debounceTimers.schedule(`file:${filePath}`, () => {
+          log.info({ file: filePath }, "File changed, reloading");
+          handler();
+        });
+      });
+      this.watchedFiles.add(filePath);
+      log.info({ file: filePath }, `Watching ${label}`);
+    } catch (err) {
+      log.warn(
+        { err, file: filePath },
+        `Failed to watch ${label}. Hot-reload will be unavailable until restart.`,
+      );
+    }
+  }
+
   private startSoundsWatcher(onSoundsConfigChanged: () => void): void {
     const soundsDir = getSoundsDir();
     try {
@@ -331,7 +375,6 @@ export class ConfigWatcher {
 
     const exactSignalHandlers: Record<string, () => void | Promise<void>> = {
       cancel: handleCancelSignal,
-      "mcp-reload": handleMcpReloadSignal,
       "conversation-undo": handleConversationUndoSignal,
       "emit-event": handleEmitEventSignal,
     };
@@ -340,7 +383,6 @@ export class ConfigWatcher {
       string,
       (filename: string) => void | Promise<void>
     > = {
-      "bash.": handleBashSignal,
       "user-message.": handleUserMessageSignal,
     };
 
@@ -485,20 +527,6 @@ export class ConfigWatcher {
   }
 }
 
-/**
- * Snapshot the current cleanup config so we can compare it against the
- * post-reload value. Tolerant of config-load failures — if the config can't
- * be read (e.g. first-load), returns undefined so the comparison below
- * treats it as "no previous value".
- */
-function safeGetCleanupConfig(): MemoryCleanupConfig | undefined {
-  try {
-    return getConfig().memory?.cleanup;
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * Return true if any cleanup field the user can change via the UI differs
  * between the previous and next config snapshots. Used to decide whether to
@@ -529,6 +557,7 @@ export function cleanupSettingsChanged(
   return (
     prev.llmRequestLogRetentionMs !== next.llmRequestLogRetentionMs ||
     prev.conversationRetentionDays !== next.conversationRetentionDays ||
+    prev.traceEventRetentionDays !== next.traceEventRetentionDays ||
     prev.enabled !== next.enabled
   );
 }