@vellumai/assistant 0.6.3 → 0.6.5

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/host-browser-proxy.ts

@@ -77,7 +77,8 @@ export class HostBrowserProxy {
           "Host browser proxy request timed out",
         );
         resolve({
-          content: "Host browser proxy timed out waiting for client response",
+          content:
+            "Host browser proxy timed out waiting for extension response (check browser-relay connectivity and /v1/host-browser-result callback failures such as 404/401).",
           isError: true,
         });
       }, timeoutSec * 1000);

package/src/daemon/lifecycle.ts

@@ -1,5 +1,9 @@
+import { join } from "node:path";
+
 import { config as dotenvConfig } from "dotenv";
 
+import type { BackupWorkerHandle } from "../backup/backup-worker.js";
+import { startBackupWorker } from "../backup/backup-worker.js";
 import { setPointerMessageProcessor } from "../calls/call-pointer-messages.js";
 import { reconcileCallsOnStartup } from "../calls/call-recovery.js";
 import { setRelayBroadcast } from "../calls/relay-server.js";
@@ -34,6 +38,11 @@ import {
 } from "../credential-execution/startup-timeout.js";
 import { FilingService } from "../filing/filing-service.js";
 import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
+import {
+  type FeedSchedulerHandle,
+  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";
@@ -65,7 +74,6 @@ import {
 import { backfillManualTokenConnections } from "../oauth/manual-token-connection.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.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";
@@ -82,6 +90,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,
@@ -89,6 +98,7 @@ import {
   setCesReconnect,
 } from "../security/secure-keys.js";
 import { UsageTelemetryReporter } from "../telemetry/usage-telemetry-reporter.js";
+import { registerBuiltinTtsProviders } from "../tts/providers/register-builtins.js";
 import { getDeviceId } from "../util/device-id.js";
 import { getLogger, initLogger } from "../util/logger.js";
 import {
@@ -270,6 +280,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();
@@ -292,8 +332,8 @@ export async function runDaemon(): Promise<void> {
     // Pre-populate the feature flag cache from the gateway so all
     // subsequent sync isAssistantFeatureFlagEnabled() calls have data.
     // Fired non-blocking so a slow or unreachable gateway doesn't delay
-    // daemon startup (the fetch has a 10s timeout that would otherwise
-    // stall the critical path).
+    // daemon startup (the IPC call has a 3s connect + 5s call timeout
+    // that would otherwise stall the critical path).
     void initFeatureFlagOverrides().catch((err) =>
       log.warn({ err }, "Background feature flag init failed"),
     );
@@ -379,6 +419,29 @@ export async function runDaemon(): Promise<void> {
         );
       }
 
+      // One-time backfill of `relationship-state.json` for existing or
+      // upgraded users so they don't land on an empty Home page after the
+      // Phase 3 ship. Runs after DB init + workspace migrations so the
+      // writer can actually resolve the guardian persona file and list
+      // connected OAuth providers — firing this from `ensurePromptFiles()`
+      // would be too early (DB isn't ready yet) and produce a degraded
+      // snapshot with zero facts and zero unlocked capabilities.
+      //
+      // Deferred via `setImmediate` so any sync filesystem/DB work the
+      // writer does (`readdirSync`, `readFileSync`, contact + provider
+      // lookups) happens on a later tick, off the startup critical path.
+      // Failures are logged — not silenced — to match the pattern used by
+      // other `void … .catch()` fire-and-forgets in this file and the
+      // assistant/CLAUDE.md rule that all errors must be observable.
+      setImmediate(() => {
+        void backfillRelationshipStateIfMissing().catch((err) =>
+          log.warn(
+            { err },
+            "Relationship state backfill failed — continuing startup",
+          ),
+        );
+      });
+
       // Backfill injection templates on Slack bot token credentials so the
       // credential proxy can inject Authorization headers. Safe on every startup.
       try {
@@ -463,10 +526,10 @@ export async function runDaemon(): Promise<void> {
         );
       }
 
-      // Write a dev-only fallback capability token to `~/.vellum/daemon-token`
-      // so developers can manually pair the chrome extension without the
-      // native messaging helper. Production pairing goes through
-      // `POST /v1/browser-extension-pair` via the native helper.
+      // Write a dev-only fallback capability token to the per-instance
+      // protected directory so developers can manually pair the chrome
+      // extension without the native messaging helper. Production pairing
+      // goes through `POST /v1/browser-extension-pair` via the native helper.
       try {
         writeDaemonTokenFallback(localGuardianPrincipalId);
       } catch (err) {
@@ -476,12 +539,6 @@ export async function runDaemon(): Promise<void> {
         );
       }
 
-      try {
-        syncUpdateBulletinOnStartup();
-      } catch (err) {
-        log.warn({ err }, "Bulletin sync failed — continuing startup");
-      }
-
       // Recover orphaned work items that were left in 'running' state when the
       // daemon previously crashed or was killed mid-task.
       const orphanedRunning = listWorkItems({ status: "running" });
@@ -591,18 +648,36 @@ export async function runDaemon(): Promise<void> {
       // falling back to the encrypted file store.
       if (cesResult.processManager) {
         const pm = cesResult.processManager;
+
+        // Snapshot the managed-proxy context and assistant ID at CES startup
+        // so the reconnect closure below never calls back into
+        // `resolveManagedProxyContext()`. That function reads the assistant
+        // API key via `getSecureKeyAsync()`, which — once `setCesClient()`
+        // has resolved the backend to CES RPC — routes the read through CES
+        // itself. During a reconnect the old transport is dead and a new
+        // one is being set up by this very closure, so the nested credential
+        // read recursively awaits its own in-flight reconnection and
+        // deadlocks until `CREDENTIAL_OP_TIMEOUT_MS` (45s) fires. That
+        // 45-second stall delays every CES restart and causes dependent
+        // credential reads (e.g. Meet's STT provider resolution) to return
+        // `undefined` during the window. API key rotation uses the
+        // `updateAssistantApiKey` RPC on the live client, not a reconnect,
+        // so caching at startup is safe.
+        const startupProxyCtx = await resolveManagedProxyContext();
+        const startupAssistantId = getPlatformAssistantId();
+
         setCesReconnect(async () => {
           try {
             await pm.stop();
             const transport = await pm.start();
             const newClient = createCesClient(transport);
-            const proxyCtx = await resolveManagedProxyContext();
-            const assistantId = getPlatformAssistantId();
             const { accepted, reason } = await newClient.handshake({
-              ...(proxyCtx.assistantApiKey
-                ? { assistantApiKey: proxyCtx.assistantApiKey }
+              ...(startupProxyCtx.assistantApiKey
+                ? { assistantApiKey: startupProxyCtx.assistantApiKey }
+                : {}),
+              ...(startupAssistantId
+                ? { assistantId: startupAssistantId }
                 : {}),
-              ...(assistantId ? { assistantId } : {}),
             });
             if (accepted) {
               log.info("CES reconnection handshake accepted");
@@ -637,12 +712,31 @@ export async function runDaemon(): Promise<void> {
     await server.start();
     log.info("Daemon startup: DaemonServer started");
 
-    // Mutable refs for Qdrant and memory worker so background init can assign
-    // them and the shutdown handler always sees the latest value.
+    // 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: {
       qdrantManager: QdrantManager | null;
       memoryWorker: { stop(): void } | null;
-    } = { qdrantManager: null, memoryWorker: null };
+      backupWorker: BackupWorkerHandle | null;
+    } = { qdrantManager: null, memoryWorker: null, backupWorker: null };
 
     // Initialize Qdrant vector store and memory worker in the background so the
     // RuntimeHttpServer can start accepting requests without waiting for Qdrant.
@@ -720,11 +814,43 @@ 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");
       bgRefs.memoryWorker = startMemoryJobsWorker();
 
+      log.info("Daemon startup: starting backup worker");
+      try {
+        bgRefs.backupWorker = startBackupWorker();
+      } catch (err) {
+        log.warn(
+          { err },
+          "Backup worker failed to start — continuing without backups",
+        );
+      }
+
       // Seed capability graph nodes (new memory graph system)
       try {
         const {
@@ -760,11 +886,6 @@ export async function runDaemon(): Promise<void> {
       }
     }
 
-    // Fire-and-forget: Qdrant init runs concurrently with the rest of startup
-    void initializeQdrantAndMemory().catch((err) =>
-      log.warn({ err }, "Background Qdrant init failed"),
-    );
-
     registerWatcherProviders();
     registerMessagingProviders();
 
@@ -889,6 +1010,19 @@ export async function runDaemon(): Promise<void> {
       },
     );
 
+    // Home activity feed scheduler — drives the assistant reflection
+    // loop + the platform Gmail digest. Fire-and-forget; a startup
+    // failure must never block the rest of daemon boot (CLAUDE.md).
+    let feedScheduler: FeedSchedulerHandle | null = null;
+    try {
+      feedScheduler = startFeedScheduler();
+    } catch (err) {
+      log.warn(
+        { err },
+        "Failed to start home feed scheduler — continuing startup",
+      );
+    }
+
     // Start the runtime HTTP server. Required for iOS pairing (gateway proxies
     // to it) and optional REST API access. Defaults to port 7821.
     let runtimeHttp: RuntimeHttpServer | null = null;
@@ -1027,8 +1161,19 @@ export async function runDaemon(): Promise<void> {
       onProviderCredentialsChanged: () =>
         server.refreshConversationsForProviderChange(),
       getHeartbeatService: () => server.getHeartbeatService(),
+      getFilingService: () => server.getFilingService(),
     });
 
+    // Fire-and-forget: Qdrant init and memory worker startup run concurrently
+    // with the rest of daemon boot. Must run AFTER `new RuntimeHttpServer(...)`
+    // so the analyze-deps singleton (populated inside `buildRouteTable()`) is
+    // available before the memory worker can claim leftover
+    // `conversation_analyze` jobs from a prior run. See the daemon-startup
+    // ordering test in `assistant/src/daemon/__tests__/`.
+    void initializeQdrantAndMemory().catch((err) =>
+      log.warn({ err }, "Background Qdrant init failed"),
+    );
+
     // Inject voice bridge deps BEFORE attempting to start the HTTP server.
     // The bridge must be available even when the HTTP server fails to bind.
     setVoiceBridgeDeps({
@@ -1208,6 +1353,17 @@ export async function runDaemon(): Promise<void> {
       runtimeHttp = null;
     }
 
+    // Register built-in TTS providers so the provider abstraction can resolve
+    // them by ID. Must happen before call controllers or routes are created.
+    try {
+      registerBuiltinTtsProviders();
+    } catch (err) {
+      log.warn(
+        { err },
+        "TTS provider registration failed — continuing with degraded TTS",
+      );
+    }
+
     // Initialize providers and tools after the HTTP server is listening so
     // health-check and pairing requests can be served immediately.  Wrapped in
     // its own try/catch so a failure here doesn't tear down the running HTTP
@@ -1333,6 +1489,7 @@ export async function runDaemon(): Promise<void> {
         }),
     });
     filing.start();
+    server.setFilingService(filing);
     log.info(
       {
         enabled: filingConfig.enabled,
@@ -1356,7 +1513,9 @@ export async function runDaemon(): Promise<void> {
       hookManager,
       runtimeHttp,
       scheduler,
+      feedScheduler,
       getMemoryWorker: () => bgRefs.memoryWorker,
+      getBackupWorker: () => bgRefs.backupWorker,
       getQdrantManager: () => bgRefs.qdrantManager,
       mcpManager,
       telemetryReporter,

package/src/daemon/message-protocol.ts

@@ -22,12 +22,14 @@ export * from "./message-types/conversations.js";
 export * from "./message-types/diagnostics.js";
 export * from "./message-types/documents.js";
 export * from "./message-types/guardian-actions.js";
+export * from "./message-types/home.js";
 export * from "./message-types/host-bash.js";
 export * from "./message-types/host-browser.js";
 export * from "./message-types/host-cu.js";
 export * from "./message-types/host-file.js";
 export * from "./message-types/inbox.js";
 export * from "./message-types/integrations.js";
+export * from "./message-types/meet.js";
 export * from "./message-types/memory.js";
 export * from "./message-types/messages.js";
 export * from "./message-types/notifications.js";
@@ -77,6 +79,7 @@ import type {
   _GuardianActionsClientMessages,
   _GuardianActionsServerMessages,
 } from "./message-types/guardian-actions.js";
+import type { _HomeServerMessages } from "./message-types/home.js";
 import type { _HostBashServerMessages } from "./message-types/host-bash.js";
 import type {
   _HostBrowserClientMessages,
@@ -92,6 +95,7 @@ import type {
   _IntegrationsClientMessages,
   _IntegrationsServerMessages,
 } from "./message-types/integrations.js";
+import type { _MeetServerMessages } from "./message-types/meet.js";
 import type { _MemoryServerMessages } from "./message-types/memory.js";
 import type {
   _MessagesClientMessages,
@@ -191,10 +195,12 @@ export type ServerMessage =
   | _SubagentsServerMessages
   | _DocumentsServerMessages
   | _GuardianActionsServerMessages
+  | _HomeServerMessages
   | _HostBashServerMessages
   | _HostBrowserServerMessages
   | _HostCuServerMessages
   | _HostFileServerMessages
+  | _MeetServerMessages
   | _MemoryServerMessages
   | _WorkspaceServerMessages
   | _SchedulesServerMessages

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

@@ -434,6 +434,19 @@ export interface ContextCompacted {
   summaryModel: string;
 }
 
+/**
+ * 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.
+ */
+export interface CompactionCircuitOpen {
+  type: "compaction_circuit_open";
+  reason: "3_consecutive_failures";
+  /** Timestamp (ms since epoch) when the breaker will allow auto-compaction again. */
+  openUntil: number;
+}
+
 export type ConversationErrorCode =
   | "PROVIDER_NETWORK"
   | "PROVIDER_RATE_LIMIT"
@@ -461,6 +474,20 @@ export interface ConversationErrorMessage {
   errorCategory?: string;
 }
 
+/** Reason the conversation list was invalidated. */
+export type ConversationListInvalidatedReason =
+  | "created"
+  | "renamed"
+  | "deleted"
+  | "reordered"
+  | "seen_changed";
+
+/** Server push — tells clients their sidebar conversation list is stale. */
+export interface ConversationListInvalidated {
+  type: "conversation_list_invalidated";
+  reason: ConversationListInvalidatedReason;
+}
+
 /** Server push — broadcast when a schedule creates a conversation. */
 export interface ScheduleConversationCreated {
   type: "schedule_conversation_created";
@@ -469,6 +496,23 @@ export interface ScheduleConversationCreated {
   title: string;
 }
 
+/**
+ * Server push — instructs the client to open and focus a conversation. If
+ * the conversation isn't already present in the client's sidebar list (e.g.
+ * it was just created via `POST /v1/conversations`), the client should stub
+ * a sidebar entry using the provided `title` before navigating.
+ */
+export interface OpenConversation {
+  type: "open_conversation";
+  conversationId: string;
+  /** Optional conversation title; supplied when the client may not yet have the conversation in its list. */
+  title?: string;
+  /** Optional message ID to scroll to after focus. */
+  anchorMessageId?: string;
+  /** When `false`, the client should register the conversation in its sidebar (so it's visible and navigable) but must NOT switch focus to it. Omitting the field defaults to `true` for backward compatibility with existing single-target 'jump to conversation' callers. */
+  focus?: boolean;
+}
+
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
 export type _ConversationsClientMessages =
@@ -500,6 +544,7 @@ export type _ConversationsServerMessages =
   | UsageUpdate
   | UsageResponse
   | ContextCompacted
+  | CompactionCircuitOpen
   | ConversationErrorMessage
   | ConversationInfo
   | ConversationTitleUpdated
@@ -507,4 +552,6 @@ export type _ConversationsServerMessages =
   | ConversationsClearResponse
   | ConversationSearchResponse
   | MessageContentResponse
-  | ScheduleConversationCreated;
+  | ConversationListInvalidated
+  | ScheduleConversationCreated
+  | OpenConversation;