@vellumai/assistant 0.6.4 → 0.6.6

package/src/daemon/handlers/slack-channel-oauth-install.ts

@@ -0,0 +1,197 @@
+/**
+ * Runs an OAuth2 loopback flow to install the user's Slack app and capture
+ * bot + user tokens in a single exchange.
+ *
+ * Prerequisites: client_id, client_secret, and app_token must already be
+ * stored in the credential vault (service: slack_channel).
+ *
+ * The handler reads client credentials from secure storage, starts a
+ * loopback OAuth server on port 17322, opens the browser to Slack's
+ * authorize URL, and waits for the user to click "Allow". Slack's
+ * oauth.v2.access response contains both the bot token (access_token)
+ * and user token (authed_user.access_token). Both are stored via
+ * setSlackChannelConfig.
+ */
+
+import { credentialKey } from "../../security/credential-key.js";
+import { startOAuth2Flow } from "../../security/oauth2.js";
+import { getSecureKeyAsync } from "../../security/secure-keys.js";
+import { openInHostBrowser } from "../../util/browser.js";
+import { getLogger } from "../../util/logger.js";
+import { setSlackChannelConfig } from "./config-slack-channel.js";
+
+const log = getLogger("slack-channel-oauth-install");
+
+/** Port pre-registered for Slack in seed-providers.ts. */
+const SLACK_LOOPBACK_PORT = 17322;
+
+/** Bot scopes matching the manifest in SKILL.md. */
+const BOT_SCOPES = [
+  "app_mentions:read",
+  "assistant:write",
+  "channels:history",
+  "channels:join",
+  "channels:read",
+  "chat:write",
+  "files:read",
+  "files:write",
+  "groups:history",
+  "groups:read",
+  "im:history",
+  "im:read",
+  "im:write",
+  "mpim:history",
+  "mpim:read",
+  "reactions:read",
+  "reactions:write",
+  "users:read",
+];
+
+/** User scopes matching the manifest in SKILL.md. */
+const USER_SCOPES = [
+  "channels:history",
+  "channels:read",
+  "groups:history",
+  "groups:read",
+  "im:history",
+  "im:read",
+  "mpim:history",
+  "mpim:read",
+  "users:read",
+  "search:read",
+  "reactions:read",
+];
+
+export interface SlackOAuthInstallResult {
+  success: boolean;
+  hasBotToken: boolean;
+  hasUserToken: boolean;
+  error?: string;
+}
+
+export async function runSlackChannelOAuthInstall(): Promise<SlackOAuthInstallResult> {
+  // Read client credentials from secure storage
+  const clientId = await getSecureKeyAsync(
+    credentialKey("slack_channel", "client_id"),
+  );
+  if (!clientId) {
+    return {
+      success: false,
+      hasBotToken: false,
+      hasUserToken: false,
+      error:
+        "Client ID not found in credential store. Store it first via credential_store prompt (service: slack_channel, field: client_id).",
+    };
+  }
+
+  const clientSecret = await getSecureKeyAsync(
+    credentialKey("slack_channel", "client_secret"),
+  );
+  if (!clientSecret) {
+    return {
+      success: false,
+      hasBotToken: false,
+      hasUserToken: false,
+      error:
+        "Client Secret not found in credential store. Store it first via credential_store prompt (service: slack_channel, field: client_secret).",
+    };
+  }
+
+  const appToken = await getSecureKeyAsync(
+    credentialKey("slack_channel", "app_token"),
+  );
+  if (!appToken) {
+    return {
+      success: false,
+      hasBotToken: false,
+      hasUserToken: false,
+      error:
+        "App Token not found in credential store. Store it first via credential_store prompt (service: slack_channel, field: app_token).",
+    };
+  }
+
+  log.info("Starting Slack OAuth install flow via loopback");
+
+  let result;
+  try {
+    result = await startOAuth2Flow(
+      {
+        authorizeUrl: "https://slack.com/oauth/v2/authorize",
+        tokenExchangeUrl: "https://slack.com/api/oauth.v2.access",
+        scopes: BOT_SCOPES,
+        clientId,
+        clientSecret,
+        scopeSeparator: ",",
+        authorizeParams: {
+          user_scope: USER_SCOPES.join(","),
+        },
+      },
+      {
+        openUrl: (url) => openInHostBrowser(url),
+      },
+      {
+        callbackTransport: "loopback",
+        loopbackPort: SLACK_LOOPBACK_PORT,
+      },
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.error({ err: msg }, "Slack OAuth install flow failed");
+    return {
+      success: false,
+      hasBotToken: false,
+      hasUserToken: false,
+      error: `OAuth flow failed: ${msg}`,
+    };
+  }
+
+  // Slack's oauth.v2.access returns:
+  //   access_token: "xoxb-..." (bot token)
+  //   authed_user: { access_token: "xoxp-..." } (user token)
+  const raw = result.rawTokenResponse;
+  const botToken = raw.access_token as string | undefined;
+  const authedUser = raw.authed_user as { access_token?: string } | undefined;
+  const userToken = authedUser?.access_token as string | undefined;
+
+  if (!botToken) {
+    log.error(
+      { rawKeys: Object.keys(raw) },
+      "Slack OAuth response missing bot access_token",
+    );
+    return {
+      success: false,
+      hasBotToken: false,
+      hasUserToken: false,
+      error:
+        "Slack OAuth response did not include a bot token (access_token). The app may not have bot scopes configured.",
+    };
+  }
+
+  log.info(
+    { hasBotToken: true, hasUserToken: !!userToken },
+    "Slack OAuth tokens received, storing via setSlackChannelConfig",
+  );
+
+  // Store bot token (and user token if present) via the Slack channel handler,
+  // which validates tokens and persists workspace metadata.
+  const configResult = await setSlackChannelConfig(
+    botToken,
+    appToken,
+    userToken,
+  );
+
+  if (!configResult.success) {
+    return {
+      success: false,
+      hasBotToken: false,
+      hasUserToken: false,
+      error: configResult.error ?? "Failed to store Slack tokens",
+    };
+  }
+
+  return {
+    success: true,
+    hasBotToken: true,
+    hasUserToken: !!userToken,
+  };
+}

package/src/daemon/lifecycle.ts

@@ -1,3 +1,5 @@
+import { join } from "node:path";
+
 import { config as dotenvConfig } from "dotenv";
 
 import type { BackupWorkerHandle } from "../backup/backup-worker.js";
@@ -10,8 +12,6 @@ import { setVoiceBridgeDeps } from "../calls/voice-session-bridge.js";
 import { initFeatureFlagOverrides } from "../config/assistant-feature-flags.js";
 import {
   getPlatformAssistantId,
-  getQdrantHttpPortEnv,
-  getQdrantUrlEnv,
   getRuntimeHttpHost,
   getRuntimeHttpPort,
   setIngressPublicBaseUrl,
@@ -41,8 +41,6 @@ import {
   startFeedScheduler,
 } from "../home/feed-scheduler.js";
 import { backfillRelationshipStateIfMissing } from "../home/relationship-state-writer.js";
-import { getHookManager } from "../hooks/manager.js";
-import { installTemplates } from "../hooks/templates.js";
 import { closeSentry, initSentry, setSentryDeviceId } from "../instrument.js";
 import { getMcpServerManager } from "../mcp/manager.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
@@ -61,7 +59,7 @@ import {
 } from "../memory/embedding-backend.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
 import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
-import { initQdrantClient } from "../memory/qdrant-client.js";
+import { initQdrantClient, resolveQdrantUrl } from "../memory/qdrant-client.js";
 import { QdrantManager } from "../memory/qdrant-manager.js";
 import { rotateToolInvocations } from "../memory/tool-usage-store.js";
 import { deleteOldTraceEvents } from "../memory/trace-event-store.js";
@@ -71,8 +69,8 @@ import {
 } from "../notifications/emit-signal.js";
 import { backfillManualTokenConnections } from "../oauth/manual-token-connection.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
+import { loadUserPlugins } from "../plugins/user-loader.js";
 import { ensurePromptFiles } from "../prompts/system-prompt.js";
-import { syncUpdateBulletinOnStartup } from "../prompts/update-bulletin.js";
 import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
@@ -89,6 +87,7 @@ import {
 } from "../runtime/capability-tokens.js";
 import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { recoverInterruptedImport } from "../runtime/migrations/vbundle-streaming-importer.js";
 import { startScheduler } from "../schedule/scheduler.js";
 import {
   onCesClientChanged,
@@ -105,6 +104,7 @@ import {
   getInterfacesDir,
   getWorkspaceDir,
 } from "../util/platform.js";
+import { APP_VERSION } from "../version.js";
 import {
   listWorkItems,
   updateWorkItem,
@@ -122,6 +122,7 @@ import {
   cleanupPidFileIfOwner,
   writePid,
 } from "./daemon-control.js";
+import { bootstrapPlugins } from "./external-plugins-bootstrap.js";
 import {
   createGuardianActionCopyGenerator,
   createGuardianFollowUpConversationGenerator,
@@ -146,7 +147,6 @@ import {
 import { seedInterfaceFiles } from "./seed-files.js";
 import { DaemonServer } from "./server.js";
 import { installShutdownHandlers } from "./shutdown-handlers.js";
-import { handleWatchObservation } from "./watch-handler.js";
 
 // Re-export public API so existing consumers don't need to change imports
 export type { StopResult } from "./daemon-control.js";
@@ -278,6 +278,36 @@ export async function runDaemon(): Promise<void> {
 
     ensureDataDir();
 
+    // Recover from any streaming `.vbundle` import that was interrupted by a
+    // crash or SIGKILL. If the previous process died between
+    // `carryOverPreservedPaths` and the atomic workspace swap, the live
+    // workspace may be missing `data/db` / `data/qdrant` / etc. The marker
+    // at `<workspaceDir>.import-marker.json` (persisted before any rename
+    // runs) tells us where the orphaned preserved paths landed; the
+    // recovery helper moves them back into the live workspace and cleans
+    // up the temp tree. Running this BEFORE `initializeDb()` ensures the
+    // DB singleton opens against the fully-restored `assistant.db`.
+    try {
+      const recoveryResult = await recoverInterruptedImport(getWorkspaceDir());
+      if (!recoveryResult.ok) {
+        // Rollback is intentionally unresolved — backup/temp/marker are
+        // preserved on disk so an operator (or a later retry) can finish
+        // the recovery. Log loudly so ops sees it, but don't block start-up:
+        // the daemon still needs to come up for diagnostics. The next
+        // `streamCommitImport` will refuse to start a new import until the
+        // marker is resolved.
+        log.error(
+          { failedCount: recoveryResult.failedCount },
+          "Interrupted-import recovery is INCOMPLETE; leftover .pre-import-* / .import-* scratch dirs remain in the workspace. Manual intervention may be required before the next import can run.",
+        );
+      }
+    } catch (err) {
+      log.warn(
+        { err },
+        "recoverInterruptedImport threw during daemon startup; continuing",
+      );
+    }
+
     // Load (or generate + persist) the auth signing key so tokens survive
     // daemon restarts.
     const signingKey = resolveSigningKey();
@@ -308,8 +338,7 @@ export async function runDaemon(): Promise<void> {
 
     seedInterfaceFiles();
 
-    log.info("Daemon startup: installing templates and initializing DB");
-    installTemplates();
+    log.info("Daemon startup: initializing DB");
     ensurePromptFiles();
 
     // DB must be initialized before workspace migrations because some
@@ -543,18 +572,6 @@ export async function runDaemon(): Promise<void> {
     log.info("Daemon startup: loading config");
     const config = loadConfig();
 
-    // Run bulletin sync AFTER the config merge + load so that getConfig()
-    // inside syncUpdateBulletinOnStartup() observes the fully merged config.
-    // Running it earlier would populate the config cache with pre-merge
-    // values, poisoning every downstream getConfig() consumer.
-    if (dbReady) {
-      try {
-        syncUpdateBulletinOnStartup();
-      } catch (err) {
-        log.warn({ err }, "Bulletin sync failed — continuing startup");
-      }
-    }
-
     // Seed module-level ingress state from the workspace config so that
     // getIngressPublicBaseUrl() returns the correct value immediately after
     // startup (before any handleIngressConfig("set") call). Without this,
@@ -655,7 +672,9 @@ export async function runDaemon(): Promise<void> {
               ...(startupProxyCtx.assistantApiKey
                 ? { assistantApiKey: startupProxyCtx.assistantApiKey }
                 : {}),
-              ...(startupAssistantId ? { assistantId: startupAssistantId } : {}),
+              ...(startupAssistantId
+                ? { assistantId: startupAssistantId }
+                : {}),
             });
             if (accepted) {
               log.info("CES reconnection handshake accepted");
@@ -677,6 +696,33 @@ export async function runDaemon(): Promise<void> {
       }
     }
 
+    // Populate the registry with user plugins from `~/.vellum/plugins/*`
+    // AFTER first-party plugins have already registered via their static
+    // side-effect imports. User plugins may fail to load individually; a
+    // failing user plugin is logged and skipped so one bad install can't
+    // prevent the daemon from starting. Ordering is load-bearing:
+    //   first-party registrations → user registrations → bootstrap (init).
+    // Both groups are fully registered before any `init()` runs so plugins
+    // that depend on each other's registration observably see a stable
+    // registry at init time.
+    await loadUserPlugins();
+
+    // Bootstrap registered plugins. Runs after the plugin registry is
+    // populated (first-party static side-effect imports + user plugins
+    // loaded above) and before the DaemonServer starts handling
+    // conversations. Credential resolution + per-plugin storage directory
+    // creation happen here. Wrapped in try/catch so a failing plugin can't
+    // block daemon startup — bootstrapPlugins internally tears down any
+    // partially-initialized plugins before throwing.
+    try {
+      await bootstrapPlugins({ config, assistantVersion: APP_VERSION });
+    } catch (err) {
+      log.warn(
+        { err },
+        "Plugin bootstrap failed — continuing startup with degraded plugin functionality",
+      );
+    }
+
     // Start the DaemonServer (conversation manager) before Qdrant so HTTP
     // routes can begin accepting requests while Qdrant initializes.
     log.info("Daemon startup: starting DaemonServer");
@@ -690,6 +736,24 @@ export async function runDaemon(): Promise<void> {
     await server.start();
     log.info("Daemon startup: DaemonServer started");
 
+    // Kick off the update bulletin background job AFTER `server.start()`
+    // resolves. `server.start()` installs the default wake resolver (via
+    // `registerDefaultWakeResolver()`), which the job depends on to actually
+    // invoke the agent. Dispatching before that point races the resolver
+    // registration and causes `wakeAgentForOpportunity()` to silently return
+    // `{invoked: false}`, leaving an orphan background conversation and a
+    // wasted LLM title-generation call every startup.
+    //
+    // Kept fire-and-forget (`void import(...).then(...).catch(...)`) so the
+    // daemon never blocks startup on it.
+    if (dbReady) {
+      void import("../prompts/update-bulletin-job.js")
+        .then((m) => m.runUpdateBulletinJobIfNeeded())
+        .catch((err) =>
+          log.warn({ err }, "Update bulletin job failed — continuing startup"),
+        );
+    }
+
     // Mutable refs for Qdrant, memory worker, and backup worker so background
     // init can assign them and the shutdown handler always sees the latest value.
     const bgRefs: {
@@ -701,13 +765,7 @@ export async function runDaemon(): Promise<void> {
     // Initialize Qdrant vector store and memory worker in the background so the
     // RuntimeHttpServer can start accepting requests without waiting for Qdrant.
     async function initializeQdrantAndMemory(): Promise<void> {
-      // Prefer QDRANT_HTTP_PORT (locally-spawned Qdrant on a specific port) over
-      // QDRANT_URL (external Qdrant instance) so the CLI can set the port without
-      // triggering QdrantManager's external mode which skips local process spawn.
-      const qdrantHttpPort = getQdrantHttpPortEnv();
-      const qdrantUrl = qdrantHttpPort
-        ? `http://127.0.0.1:${qdrantHttpPort}`
-        : getQdrantUrlEnv() || config.memory.qdrant.url;
+      const qdrantUrl = resolveQdrantUrl(config);
       log.info({ qdrantUrl }, "Daemon startup: initializing Qdrant");
       const manager = new QdrantManager({ url: qdrantUrl });
       bgRefs.qdrantManager = manager;
@@ -774,6 +832,28 @@ export async function runDaemon(): Promise<void> {
             "Qdrant client initialization failed — memory features will be degraded",
           );
         }
+
+        // Reconcile the PKB Qdrant index against the on-disk tree. Kept
+        // inside the `qdrantStarted` guard so we don't call
+        // `getQdrantClient()` (which throws "not initialized") on every
+        // startup when Qdrant is unavailable. Fire-and-forget so enqueued
+        // re-index jobs drain in the background and first-turn latency
+        // stays unaffected.
+        void (async () => {
+          try {
+            const { reconcilePkbIndex } =
+              await import("../memory/pkb/pkb-reconcile.js");
+            const { PKB_WORKSPACE_SCOPE } =
+              await import("../memory/pkb/types.js");
+            const pkbRoot = join(getWorkspaceDir(), "pkb");
+            await reconcilePkbIndex(pkbRoot, PKB_WORKSPACE_SCOPE);
+          } catch (err) {
+            log.warn(
+              { err },
+              "PKB index reconciliation failed — continuing startup",
+            );
+          }
+        })();
       }
 
       log.info("Daemon startup: starting memory worker");
@@ -879,29 +959,6 @@ export async function runDaemon(): Promise<void> {
           throwOnError: true,
         });
       },
-      (schedule) => {
-        void emitNotificationSignal({
-          sourceEventName: "schedule.complete",
-          sourceChannel: "scheduler",
-          sourceContextId: schedule.id,
-          attentionHints: {
-            requiresAction: false,
-            urgency: "medium",
-            isAsyncBackground: true,
-            visibleInSourceNow: false,
-          },
-          contextPayload: {
-            scheduleId: schedule.id,
-            name: schedule.name,
-          },
-          conversationMetadata: {
-            groupId: "system:scheduled",
-            scheduleJobId: schedule.id,
-            source: "schedule",
-          },
-          dedupeKey: `schedule:complete:${schedule.id}:${Date.now()}`,
-        });
-      },
       (notification) => {
         void emitNotificationSignal({
           sourceEventName: "watcher.notification",
@@ -1070,28 +1127,6 @@ export async function runDaemon(): Promise<void> {
           );
         },
       },
-      getWatchDeps: () => {
-        const ctx = server.getHandlerContext();
-        return {
-          handleWatchObservation: async (params) => {
-            await handleWatchObservation(
-              {
-                type: "watch_observation",
-                watchId: params.watchId,
-                conversationId: params.conversationId,
-                ocrText: params.ocrText,
-                appName: params.appName,
-                windowTitle: params.windowTitle,
-                bundleIdentifier: params.bundleIdentifier,
-                timestamp: params.timestamp,
-                captureIndex: params.captureIndex,
-                totalExpected: params.totalExpected,
-              },
-              ctx,
-            );
-          },
-        };
-      },
       getRecordingDeps: () => ({
         getHandlerContext: () => server.getHandlerContext(),
       }),
@@ -1328,13 +1363,6 @@ export async function runDaemon(): Promise<void> {
       log.warn({ err }, "Assistant symlink installation failed — continuing");
     }
 
-    const hookManager = getHookManager();
-    hookManager.watch();
-
-    void hookManager.trigger("daemon-start", {
-      pid: process.pid,
-    });
-
     // Download embedding runtime in background (non-blocking).
     // If download fails, local embeddings gracefully fall back to cloud backends.
     void (async () => {
@@ -1448,7 +1476,6 @@ export async function runDaemon(): Promise<void> {
       workspaceHeartbeat,
       heartbeat,
       filing,
-      hookManager,
       runtimeHttp,
       scheduler,
       feedScheduler,

package/src/daemon/message-types/computer-use.ts

@@ -1,4 +1,4 @@
-// Computer use and watch observation types.
+// Computer use and recording types.
 
 import type { CommandIntent, UserMessageAttachment } from "./shared.js";
 
@@ -15,19 +15,6 @@ export interface TaskSubmit {
   commandIntent?: CommandIntent;
 }
 
-export interface WatchObservation {
-  type: "watch_observation";
-  watchId: string;
-  conversationId: string;
-  ocrText: string;
-  appName?: string;
-  windowTitle?: string;
-  bundleIdentifier?: string;
-  timestamp: number;
-  captureIndex: number;
-  totalExpected: number;
-}
-
 // === Recording ===
 
 /** Recording options shared across standalone and CU recording flows. */
@@ -89,30 +76,11 @@ export interface RecordingResume {
   recordingId: string;
 }
 
-export interface WatchStarted {
-  type: "watch_started";
-  conversationId: string;
-  watchId: string;
-  durationSeconds: number;
-  intervalSeconds: number;
-}
-
-export interface WatchCompleteRequest {
-  type: "watch_complete_request";
-  conversationId: string;
-  watchId: string;
-}
-
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
-export type _ComputerUseClientMessages =
-  | TaskSubmit
-  | WatchObservation
-  | RecordingStatus;
+export type _ComputerUseClientMessages = TaskSubmit | RecordingStatus;
 
 export type _ComputerUseServerMessages =
-  | WatchStarted
-  | WatchCompleteRequest
   | RecordingStart
   | RecordingStop
   | RecordingPause

package/src/daemon/message-types/conversations.ts

@@ -421,8 +421,16 @@ export interface UsageResponse {
   model: string;
 }
 
+/**
+ * Emitted after a compaction turn completes (both auto-compaction and
+ * `/compact`). Carries the fresh `estimatedInputTokens` so clients can refresh
+ * the context-window indicator without waiting for the next `usage_update`.
+ *
+ * Scoped per-conversation — see `CompactionCircuitOpen` doc for why.
+ */
 export interface ContextCompacted {
   type: "context_compacted";
+  conversationId: string;
   previousEstimatedInputTokens: number;
   estimatedInputTokens: number;
   maxInputTokens: number;
@@ -432,6 +440,59 @@ export interface ContextCompacted {
   summaryInputTokens: number;
   summaryOutputTokens: number;
   summaryModel: string;
+  /**
+   * Quality signals for the generated summary. Emitted for every
+   * compaction (including truncation-only paths where the summary text
+   * is unchanged from the prior pass). Consumers can use these to detect
+   * regressions without needing to read the summary text itself.
+   *
+   * - `summaryCharCount`: length of the produced summary text.
+   * - `summaryHeaderCount`: number of `## ` section headers in the summary.
+   * - `summaryHadMemoryEcho`: `true` if the summary contains any runtime
+   *   injection tag (e.g. `<memory`, `<turn_context>`, `<workspace>`).
+   *   Should always be `false` — `true` indicates the compaction strip
+   *   logic failed to remove an injected block from the summarizer input.
+   */
+  summaryCharCount?: number;
+  summaryHeaderCount?: number;
+  summaryHadMemoryEcho?: boolean;
+}
+
+/**
+ * Emitted when the compaction circuit breaker trips. After three consecutive
+ * summary-LLM failures (with local fallback covering each), auto-compaction is
+ * suspended until `openUntil` to avoid repeatedly hammering a broken provider.
+ * User-initiated compaction (`/compact`, `force: true`) bypasses the breaker.
+ *
+ * `conversationId` scopes the event so clients can ignore breaker trips from
+ * other conversations — `EventStreamClient` broadcasts every parsed server
+ * message to all subscribers, so without this field a breaker trip in one
+ * conversation would set the "auto-compaction paused" banner on every open
+ * `ChatViewModel`.
+ */
+export interface CompactionCircuitOpen {
+  type: "compaction_circuit_open";
+  conversationId: string;
+  reason: "3_consecutive_failures";
+  /** Timestamp (ms since epoch) when the breaker will allow auto-compaction again. */
+  openUntil: number;
+}
+
+/**
+ * Emitted when the compaction circuit breaker transitions from open → closed
+ * because a successful compaction reset
+ * `ctx.compactionCircuitOpenUntil`. The Swift client clears its banner state
+ * on receipt so the "auto-compaction paused" indicator dismisses immediately
+ * instead of lingering until the original `openUntil` deadline (up to 1h).
+ *
+ * Only fires on the open→closed transition — successful compactions while
+ * the breaker was already closed would be noise.
+ *
+ * Scoped per-conversation — see `CompactionCircuitOpen` doc for why.
+ */
+export interface CompactionCircuitClosed {
+  type: "compaction_circuit_closed";
+  conversationId: string;
 }
 
 export type ConversationErrorCode =
@@ -531,6 +592,8 @@ export type _ConversationsServerMessages =
   | UsageUpdate
   | UsageResponse
   | ContextCompacted
+  | CompactionCircuitOpen
+  | CompactionCircuitClosed
   | ConversationErrorMessage
   | ConversationInfo
   | ConversationTitleUpdated