@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/daemon/conversation.ts

@@ -16,7 +16,7 @@
  */
 
 import { repairHistory } from "../agent/history-repair/history-repair.js";
-import type { AgentLoopConfig } from "../agent/loop.js";
+import type { AgentLoopConfig, PreparedModelCall } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type { AssistantActivityStateEvent } from "../api/events/assistant-activity-state.js";
 import type { ConfirmationStateChangedEvent } from "../api/events/confirmation-state-changed.js";
@@ -39,6 +39,7 @@ import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite, Speed } from "../config/schemas/llm.js";
 import { resolveSendUserMessageActive } from "../config/send-user-message-gate.js";
+import { isSessionGroupsEnabled } from "../config/session-groups-gate.js";
 import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
@@ -118,6 +119,8 @@ import { withSqliteRetry } from "../util/sqlite-retry.js";
 import type { WorkspaceGitService } from "../workspace/git-service.js";
 import type { commitTurnChanges } from "../workspace/turn-commit.js";
 import type { AssistantAttachmentDraft } from "./assistant-attachments.js";
+import { BrowserModeSessionProducer } from "./browser-mode-session.js";
+import { ComputerUseModeSessionProducer } from "./computer-use-mode-session.js";
 import type { AssistantSurface } from "./conversation-agent-loop.js";
 import {
   applyCompactionResult,
@@ -141,6 +144,7 @@ import {
   persistUserMessage as persistUserMessageImpl,
   redirectToSecurePrompt as redirectToSecurePromptImpl,
 } from "./conversation-messaging.js";
+import { ConversationModeSessionCoordinator } from "./conversation-mode-session.js";
 // Extracted modules
 import { registerConversationNotifiers } from "./conversation-notifiers.js";
 import type { ProcessMessageOptions } from "./conversation-process.js";
@@ -193,6 +197,7 @@ import { filterMessagesForUntrustedActor } from "./message-provenance.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import { isHostProxyTransport } from "./message-types/conversations.js";
 import { conversationMetadataSyncTag } from "./message-types/sync.js";
+import { bestEffortModeSessionTracking } from "./mode-session-tracking.js";
 import { renderReactionHistoryText } from "./reaction-history-render.js";
 import type { QueuedReactionRecord } from "./reaction-record.js";
 import {
@@ -201,6 +206,7 @@ import {
 } from "./summarize-boundary.js";
 
 const log = getLogger("conversation");
+const PROMPT_CACHE_WARM_MAX_TOKENS = 16;
 
 /**
  * First text block of a persisted message row's content, mirroring
@@ -525,6 +531,13 @@ export class Conversation {
    */
   enabledPlugins: string[] | null = null;
   /** @internal */ currentRequestId?: string;
+  /** Canonical recorded-session ownership for this conversation. */
+  readonly modeSessions: ConversationModeSessionCoordinator;
+  /** Computer-use producer mapped onto the canonical session coordinator. */
+  readonly computerUseModeSessions: ComputerUseModeSessionProducer;
+  /** Browser producer mapped onto the canonical session coordinator. */
+  readonly browserModeSessions: BrowserModeSessionProducer;
+  private liveVoiceResidencyLeases = 0;
   /**
    * The `clientMessageId` the running turn was started by, recorded in the same
    * synchronous step that takes the processing lock.
@@ -783,17 +796,22 @@ export class Conversation {
    */
   pendingInterruptActivityBridge = false;
   /**
-   * Set by `interruptRunningTurn` when the abort it ran landed with no tool
-   * call in flight, and consumed exactly once by the persist of the
-   * interrupting user message, which appends
+   * Set by `interruptRunningTurn` on every handover it completes, and consumed
+   * exactly once by the first user message persisted after it, which appends
    * {@link INTERRUPTED_TURN_NOTE_TEXT} to that message's LLM-facing content
    * and stamps `interruptedPriorTurn` on the row.
    *
-   * An interrupt caught mid-tool needs nothing here: the synthetic
-   * `tool_result` the loop or the repair writes already tells the model a
-   * message preempted it. Caught mid-provider-call there is no `tool_use` to
-   * answer, so the note is the only signal, and it rides on the message that
-   * did the interrupting.
+   * The note is the only place the behavior after an interrupt is spelled out.
+   * A synthetic `tool_result` states what happened to the one call it answers
+   * and nothing more, so an interrupt caught mid-tool arms this too.
+   *
+   * It belongs to the history position, not to the send that armed it. That
+   * first row is the one sitting directly under the work the handover stopped,
+   * so it is the row whose note the model reads in the right place. Normally it
+   * is the interrupting message itself. When that send loses the lock race and
+   * queues, the message that persists first was also sent while the assistant
+   * was working, and the note is true of it; the queued one drains after a
+   * completed turn, where the same note would be stale.
    * @internal
    */
   pendingInterruptNote = false;
@@ -975,6 +993,16 @@ export class Conversation {
     const { maxTokens, speedOverride, cacheTtl, modelOverride } = options ?? {};
     const enableNativeWebSearch = options?.enableNativeWebSearch ?? false;
     this.conversationId = conversationId;
+    this.modeSessions = new ConversationModeSessionCoordinator(conversationId);
+    this.computerUseModeSessions = new ComputerUseModeSessionProducer(
+      this.modeSessions,
+      isSessionGroupsEnabled,
+    );
+    this.browserModeSessions = new BrowserModeSessionProducer(
+      this.modeSessions,
+      1,
+      isSessionGroupsEnabled,
+    );
     this.parentConversationId = options?.parentConversationId;
     this.systemPrompt = systemPrompt;
     this.provider = provider;
@@ -1237,48 +1265,91 @@ export class Conversation {
   // ── Prompt Cache Warming ─────────────────────────────────────────
 
   /**
-   * Fire-and-forget LLM call with max_tokens=1 to populate the provider's
-   * prompt cache (system prompt + tools). Called after the canned first
-   * greeting so the user's next real message gets a cache hit.
+   * Non-rejecting LLM call with a minimal output budget to populate the selected
+   * provider's prompt cache (system prompt + tools).
    */
-  warmPromptCache(): void {
+  async warmPromptCache(options?: {
+    callSite?: LLMCallSite;
+    overrideProfile?: string;
+    forceOverrideProfile?: boolean;
+    signal?: AbortSignal;
+    systemPrompt?: string | null;
+    tools?: ToolDefinition[];
+  }): Promise<void> {
     this.cacheWarmAbort?.abort();
     const abort = new AbortController();
     this.cacheWarmAbort = abort;
 
-    const systemPrompt = this.buildCurrentSystemPrompt();
-    const tools = getAllToolDefinitions();
-    const provider = this.provider;
+    const externalSignal = options?.signal;
+    const relayAbort = (): void => abort.abort(externalSignal?.reason);
+    if (externalSignal?.aborted) {
+      relayAbort();
+    } else {
+      externalSignal?.addEventListener("abort", relayAbort, { once: true });
+    }
 
-    const warmMessage: Message = {
-      role: "user",
-      content: [{ type: "text", text: "hi" }],
-    };
+    const callSite = options?.callSite ?? "mainAgent";
 
-    provider
-      .sendMessage([warmMessage], {
-        tools,
-        systemPrompt,
+    try {
+      const hasSystemPrompt =
+        options !== undefined &&
+        Object.prototype.hasOwnProperty.call(options, "systemPrompt");
+      const systemPrompt = hasSystemPrompt
+        ? (options.systemPrompt ?? undefined)
+        : this.buildCurrentSystemPrompt();
+      const tools =
+        options?.tools ?? this.agentLoop.getResolvedTools(this.messages);
+      const providerConfig = {
+        ...(options?.overrideProfile !== undefined
+          ? { overrideProfile: options.overrideProfile }
+          : {}),
+        ...(options?.forceOverrideProfile !== undefined
+          ? { forceOverrideProfile: options.forceOverrideProfile }
+          : {}),
+        selectionSeed: this.conversationId,
+      };
+      const warmMessage: Message = {
+        role: "user",
+        content: [{ type: "text", text: "hi" }],
+      };
+
+      await this.provider.sendMessage([warmMessage], {
+        tools: tools.length > 0 ? tools : undefined,
+        ...(systemPrompt !== undefined ? { systemPrompt } : {}),
         config: {
-          max_tokens: 1,
-          callSite: "mainAgent",
-          usageTracking: "manual",
+          max_tokens: PROMPT_CACHE_WARM_MAX_TOKENS,
+          callSite,
+          ...providerConfig,
+          conversationId: this.conversationId,
         },
         signal: abort.signal,
-      })
-      .then(() => {
-        log.info("Prompt cache warmed successfully");
-      })
-      .catch((err) => {
-        if (!abort.signal.aborted) {
-          log.warn({ err }, "Prompt cache warming failed (non-fatal)");
-        }
-      })
-      .finally(() => {
-        if (this.cacheWarmAbort === abort) {
-          this.cacheWarmAbort = undefined;
-        }
       });
+      if (!abort.signal.aborted) {
+        log.info(
+          {
+            callSite,
+            profile: options?.overrideProfile ?? null,
+          },
+          "Prompt cache warmed successfully",
+        );
+      }
+    } catch (err) {
+      if (!abort.signal.aborted) {
+        log.warn(
+          {
+            err,
+            callSite,
+            profile: options?.overrideProfile ?? null,
+          },
+          "Prompt cache warming failed (non-fatal)",
+        );
+      }
+    } finally {
+      externalSignal?.removeEventListener("abort", relayAbort);
+      if (this.cacheWarmAbort === abort) {
+        this.cacheWarmAbort = undefined;
+      }
+    }
   }
 
   // ── Lifecycle ────────────────────────────────────────────────────
@@ -2509,14 +2580,31 @@ export class Conversation {
     return !this.queue.isEmpty;
   }
 
+  acquireLiveVoiceResidency(): () => void {
+    this.liveVoiceResidencyLeases += 1;
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      this.liveVoiceResidencyLeases = Math.max(
+        0,
+        this.liveVoiceResidencyLeases - 1,
+      );
+    };
+  }
+
   /**
    * True when dropping this instance would lose work that is still in flight:
-   * a live turn, a queued successor, or a child subagent.
+   * a live turn, queued successor, child subagent, or mode-session lifecycle.
    */
   hasInFlightWork(): boolean {
     return (
       this.isProcessing() ||
       this.hasQueuedMessages() ||
+      this.liveVoiceResidencyLeases > 0 ||
+      this.modeSessions.hasResidentWork() ||
       getSubagentManager().hasActiveChildren(this.conversationId)
     );
   }
@@ -2643,6 +2731,16 @@ export class Conversation {
 
   setHostCuProxy(proxy: HostCuProxy | undefined): void {
     if (this.hostCuProxy && this.hostCuProxy !== proxy) {
+      const previousProxy = this.hostCuProxy;
+      bestEffortModeSessionTracking("computer use proxy replacement", () => {
+        this.computerUseModeSessions.endTask({
+          turnId: this.currentRequestId,
+          source: {
+            sourceId: previousProxy.sourceId,
+            generation: previousProxy.resetGeneration,
+          },
+        });
+      });
       this.hostCuProxy.dispose();
     }
     this.hostCuProxy = proxy;
@@ -3417,6 +3515,8 @@ export class Conversation {
        */
       replyDeliveredInAppOnly?: boolean;
       callSite?: LLMCallSite;
+      /** Provider configuration source when distinct from turn semantics. */
+      inferenceCallSite?: LLMCallSite;
       /**
        * Optional ad-hoc inference-profile override applied to every LLM call
        * the loop issues for this turn. Forwarded into
@@ -3428,6 +3528,8 @@ export class Conversation {
       overrideProfile?: string;
       /** Float `overrideProfile` above call-site layers for this run. */
       forceOverrideProfile?: boolean;
+      /** Observe the first finalized model request without delaying it. */
+      onFirstModelCallPrepared?: (prepared: PreparedModelCall) => void;
       /**
        * Firing's `cron_runs.id` stamped onto this turn's usage rows. Per-turn:
        * forwarded into {@link runAgentLoopImpl} and threaded to `recordUsage`.

package/src/daemon/handlers/config-model.ts

@@ -98,14 +98,16 @@ export function setImageGenModel(modelId: string, ctx: ModelSetContext): void {
   // Keep the derived provider in sync with the selected model so downstream
   // routing never sends a Gemini request to an OpenAI model (or vice versa).
   // The prefix logic is shared with workspace migration 006-services-config
-  // via providerForImageModelPrefix(). Provider "vellum" is exempt: it is
-  // managed for every model (the backend derives from the model at request
-  // time), and rewriting it here would silently move a managed user onto a
-  // BYOK provider they may hold no key for.
+  // via providerForImageModelPrefix(). Providers "vellum" and "openrouter"
+  // are exempt: vellum is managed for every model, and openrouter owns every
+  // selected slug (including google/ and openai/ prefixes). Rewriting either
+  // would silently move the user onto a BYOK provider they may hold no key
+  // for.
   const services = raw.services as
     | Record<string, { provider?: string }>
     | undefined;
-  if (services?.["image-generation"]?.provider !== "vellum") {
+  const currentProvider = services?.["image-generation"]?.provider;
+  if (currentProvider !== "vellum" && currentProvider !== "openrouter") {
     setServiceField(
       raw,
       "image-generation",

package/src/daemon/handlers/shared.ts

@@ -3,8 +3,13 @@ import {
   SENTINEL_REDACTION_VERSION,
 } from "@vellumai/service-contracts/redacted-credential";
 import { v4 as uuid } from "uuid";
+import { z } from "zod";
 
 import { AnsweredQuestionSchema } from "../../api/events/question-answered.js";
+import {
+  type ToolActivityMetadata,
+  ToolActivityMetadataSchema,
+} from "../../api/events/tool-result.js";
 import type {
   ConversationContentBlock,
   ConversationMessageAttachment,
@@ -246,6 +251,33 @@ export interface ConversationCreateOptions {
   conversationType?: ConversationCreateType;
 }
 
+/** One schema per activity entry, so each entry validates on its own. */
+const ACTIVITY_ENTRY_SCHEMAS = Object.entries(
+  ToolActivityMetadataSchema.shape,
+).map(([key, schema]) => z.object({ [key]: schema }));
+
+/**
+ * Validates a persisted `_activityMetadata` rider one tool's entry at a time.
+ * Cards render these fields directly, so an entry that no longer matches its
+ * schema is dropped (its card degrades to the result text) without taking a
+ * valid sibling entry with it.
+ */
+function readPersistedActivityMetadata(
+  value: unknown,
+): ToolActivityMetadata | undefined {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+  const activity: ToolActivityMetadata = {};
+  for (const schema of ACTIVITY_ENTRY_SCHEMAS) {
+    const parsed = schema.safeParse(value);
+    if (parsed.success) {
+      Object.assign(activity, parsed.data);
+    }
+  }
+  return Object.keys(activity).length > 0 ? activity : undefined;
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value != null;
 }
@@ -661,12 +693,12 @@ export function renderHistoryContent(
         entry.riskDirectoryScopeOptions =
           block._riskDirectoryScopeOptions as HistoryToolCall["riskDirectoryScopeOptions"];
       }
-      // Read back tool activity (web_search / web_fetch) persisted by
-      // `annotatePersistedAssistantMessage` so the activity card survives a
-      // history reopen instead of degrading to the plain result text.
-      if (isRecord(block._activityMetadata)) {
-        entry.activityMetadata =
-          block._activityMetadata as HistoryToolCall["activityMetadata"];
+      // Read back tool activity persisted by `annotatePersistedAssistantMessage`
+      // so the activity card survives a history reopen instead of degrading to
+      // the plain result text.
+      const activity = readPersistedActivityMetadata(block._activityMetadata);
+      if (activity) {
+        entry.activityMetadata = activity;
       }
       // Read back the answered `ask_question` record so the answered card
       // rehydrates from history. Validated (rather than trusted like the
@@ -708,9 +740,9 @@ export function renderHistoryContent(
       }
       // Native server tools (Anthropic web_search) persist their activity on
       // the server_tool_use block, so read it back here too.
-      if (isRecord(block._activityMetadata)) {
-        entry.activityMetadata =
-          block._activityMetadata as HistoryToolCall["activityMetadata"];
+      const activity = readPersistedActivityMetadata(block._activityMetadata);
+      if (activity) {
+        entry.activityMetadata = activity;
       }
       toolCalls.push(entry);
       if (id) {
@@ -936,17 +968,24 @@ async function mintCollectionLinkFallback(
  *
  * Lifecycle state (resolver, timer) is registered in pendingInteractions — the
  * same tracker the in-conversation SecretPrompter uses — so `POST /v1/secret`
- * resolves the prompt generically. When a `conversationId` is supplied (the CLI
- * `credentials prompt` command forwards `__CONVERSATION_ID`), the broadcast is
- * scoped to that conversation so clients deliver it; otherwise it is
- * conversation-less. When that conversation's channel cannot render dynamic UI
- * (e.g. slack, telegram), resolves immediately with `unsupported_channel` —
- * carrying a one-time collection link when the gateway can mint one — instead
- * of broadcasting a request that can only time out.
+ * resolves the prompt generically. The broadcast is scoped to the supplied
+ * `conversationId` (the CLI `credentials prompt` command forwards
+ * `__CONVERSATION_ID`) so clients deliver it. Two cases have no surface that
+ * can render the card and resolve immediately with `unsupported_channel`,
+ * carrying a one-time collection link when the gateway can mint one, instead
+ * of broadcasting a request that can only time out:
+ *   - the conversation's channel cannot render dynamic UI (slack, telegram);
+ *   - there is no conversation at all (a headless exec such as Doctor's
+ *     `run_assistant_cli`). Clients drop conversation-scoped events without a
+ *     conversationId and `/v1/pending-interactions` is keyed by conversation,
+ *     so a conversation-less `secret_request` is invisible everywhere.
  */
 export function requestSecretStandalone(
   params: StandaloneSecretParams,
 ): Promise<SecretPromptResult> {
+  if (!params.conversationId) {
+    return mintCollectionLinkFallback(params);
+  }
   const conversation = findConversation(params.conversationId);
   if (conversation && !conversationSupportsDynamicUi(conversation)) {
     return mintCollectionLinkFallback(params);

package/src/daemon/host-cu-proxy.ts

@@ -13,7 +13,6 @@
  * RPC lifecycle (resolve/reject/timer/detachAbort) is stored in
  * pendingInteractions alongside routing metadata.
  */
-
 import { v4 as uuid } from "uuid";
 
 import { loadConfig } from "../config/loader.js";
@@ -30,6 +29,7 @@ import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { resolveHostCuTarget } from "./host-cu-target.js";
+import { bestEffortModeSessionTracking } from "./mode-session-tracking.js";
 
 const log = getLogger("host-cu-proxy");
 
@@ -161,27 +161,14 @@ function isNoDiffKeyAction(action: ActionIdentity | undefined): boolean {
   );
 }
 
-/**
- * Canonical signature for loop detection. Key presses collapse equivalent
- * spellings (`cmd+a`, `command+a`, `cmd + a`) of the same combo so a stuck
- * session retrying it with alias/whitespace variants is still caught —
- * important now that exempt keys no longer emit no-effect warnings. Only the
- * `key` value is normalized; all other input fields (e.g. the routing
- * `target_client_id`) are preserved, so the same combo sent to different
- * desktop clients is not mistaken for a repeat.
- */
+/** Normalize key aliases and ignore observation tokens when detecting repeats. */
 function actionSignature(record: ActionRecord): string {
-  if (
-    record.toolName === "computer_use_key" &&
-    typeof record.input.key === "string"
-  ) {
-    const normalizedInput = {
-      ...record.input,
-      key: canonicalizeKeyCombo(record.input.key),
-    };
-    return `computer_use_key:${JSON.stringify(normalizedInput)}`;
+  const input = { ...record.input };
+  delete input.observation_id;
+  if (record.toolName === "computer_use_key" && typeof input.key === "string") {
+    input.key = canonicalizeKeyCombo(input.key);
   }
-  return `${record.toolName}:${JSON.stringify(record.input)}`;
+  return `${record.toolName}:${JSON.stringify(input)}`;
 }
 
 /**
@@ -223,6 +210,8 @@ function clientAdvertises(
 // ---------------------------------------------------------------------------
 
 export class HostCuProxy {
+  /** Stable identity for this conversation-owned proxy instance. */
+  private readonly _sourceId = uuid();
   // CU state tracking (per-conversation)
   private _stepCount = 0;
   private _maxSteps: number;
@@ -294,6 +283,14 @@ export class HostCuProxy {
     return this._actionHistory;
   }
 
+  get sourceId(): string {
+    return this._sourceId;
+  }
+
+  get resetGeneration(): number {
+    return this._resetGeneration;
+  }
+
   // ---------------------------------------------------------------------------
   // Availability
   // ---------------------------------------------------------------------------
@@ -328,6 +325,7 @@ export class HostCuProxy {
     signal?: AbortSignal,
     targetClientId?: string,
     sourceActorPrincipalId?: string,
+    onValidatedDispatch?: () => void,
   ): Promise<ToolExecutionResult> {
     if (signal?.aborted) {
       return Promise.resolve({
@@ -399,6 +397,9 @@ export class HostCuProxy {
         isError: true,
       });
     }
+    bestEffortModeSessionTracking("computer admission", () =>
+      onValidatedDispatch?.(),
+    );
     const scopedObservation = hasCaptureTarget(input);
     if (scopedObservation) {
       this._previousAXTree = undefined;
@@ -597,6 +598,30 @@ export class HostCuProxy {
     return result;
   }
 
+  /** Run a screenshot-only backend through the shared CU budget and formatter. */
+  async executeLocal(
+    toolName: string,
+    input: Record<string, unknown>,
+    execute: () => Promise<CuObservationResult>,
+  ): Promise<ToolExecutionResult> {
+    if (this._stepCount >= this._maxSteps) {
+      return {
+        content: `Step limit (${this._maxSteps}) exceeded. Call computer_use_done to finish.`,
+        isError: true,
+      };
+    }
+    const reasoning =
+      typeof input.reasoning === "string" ? input.reasoning : undefined;
+    this.recordAction(toolName, input, reasoning);
+    this._previousAXTree = undefined;
+    this._consecutiveUnchangedSteps = 0;
+    const observation = await execute();
+    return this.formatObservation(observation, undefined, false, {
+      toolName,
+      input,
+    });
+  }
+
   // ---------------------------------------------------------------------------
   // CU state management
   // ---------------------------------------------------------------------------
@@ -629,7 +654,8 @@ export class HostCuProxy {
    * stopping and puts the pointer back where the user left it, instead of
    * waiting out its idle fallback.
    */
-  endTask(conversationId: string): void {
+  endTask(conversationId: string): number {
+    const endedGeneration = this._resetGeneration;
     for (const targetClientId of this._dispatchedTargets.values()) {
       try {
         broadcastMessage(
@@ -647,10 +673,12 @@ export class HostCuProxy {
       }
     }
     this.reset();
+    return endedGeneration;
   }
 
   /** Reset all CU state. Called on terminal tools (computer_use_done, etc.). */
-  reset(): void {
+  reset(): number {
+    const endedGeneration = this._resetGeneration;
     this._dispatchedTargets.clear();
     this._stepCount = 0;
     this._previousAXTree = undefined;
@@ -658,6 +686,7 @@ export class HostCuProxy {
     this._actionHistory = [];
     this._observedTargets.clear();
     this._resetGeneration++;
+    return endedGeneration;
   }
 
   /**

package/src/daemon/lifecycle.ts

@@ -77,7 +77,6 @@ import { writePid } from "./daemon-control.js";
 import {
   setDbMigrating,
   setDbMigrationFailed,
-  setDbReady,
   setStartupComplete,
 } from "./daemon-readiness.js";
 import { startDiskPressureGuardForLifecycle } from "./disk-pressure-guard-lifecycle.js";
@@ -91,6 +90,7 @@ import {
   reconcileInterruptedConversations,
   resumeInterruptedConversations,
 } from "./interrupted-turn-reconciler.js";
+import { recoverModeSessionsBeforeDbReady } from "./mode-session-startup-recovery.js";
 import { startOrphanReaper } from "./orphan-reaper.js";
 import { runProfilerSweep } from "./profiler-run-store.js";
 import {
@@ -290,22 +290,39 @@ export async function runDaemon(): Promise<void> {
         "stream seq floor from persisted anchors failed — continuing startup",
       );
     }
+    const migrationFailureDetails = {
+      failedMigrations: initResult.failedMigrations,
+      deferredMigrations: initResult.deferredMigrations,
+      validationError: initResult.validationError,
+    };
+    const modeSessionRecovery = migrationsOk
+      ? recoverModeSessionsBeforeDbReady()
+      : null;
+    if (modeSessionRecovery?.ok && modeSessionRecovery.interruptedCount > 0) {
+      log.info(
+        { interruptedModeSessions: modeSessionRecovery.interruptedCount },
+        "Recovered active mode sessions as interrupted",
+      );
+    }
+    if (modeSessionRecovery && !modeSessionRecovery.ok) {
+      log.error(
+        { err: modeSessionRecovery.error },
+        "Mode session recovery failed; tracking is unavailable for this boot",
+      );
+    }
     if (migrationsOk) {
-      setDbReady(true);
       log.info("Daemon startup: DB initialized");
     } else {
-      setDbMigrationFailed(undefined, {
-        failedMigrations: initResult.failedMigrations,
-        deferredMigrations: initResult.deferredMigrations,
-        validationError: initResult.validationError,
-      });
+      setDbMigrationFailed(undefined, migrationFailureDetails);
+    }
+    if (!migrationsOk) {
       log.error(
         {
           failedMigrations: initResult.failedMigrations,
           deferredMigrations: initResult.deferredMigrations,
           validationError: initResult.validationError,
         },
-        "Daemon startup: DB opened but one or more migrations failed or were deferred — /readyz will remain unready",
+        "Daemon startup: DB migrations failed; /readyz will remain unready",
       );
     }
     // Migrations have settled (successfully or in the failed degraded mode),
@@ -673,11 +690,11 @@ export async function runDaemon(): Promise<void> {
   // blocked.
   startConsentRefresh();
 
-  // Bring up the assistant's CES connection (process + handshake + reconnect
-  // wiring). Blocks up to a 20s timeout so credential reads route through CES
-  // before provider init; non-fatal, falls back to the direct credential store
-  // on failure. CES serves a multi-connection bootstrap socket, so this
-  // happens at the process level and child processes can connect independently.
+  // Open the assistant's CES RPC client (handshake + reconnect wiring).
+  // Blocks up to a 20s timeout so credential reads route through CES before
+  // provider init; non-fatal, falls back to the direct credential store on
+  // failure. CES serves a multi-connection bootstrap socket, so child
+  // processes can open the same `openCesRpcSession` path independently.
   await startCes(config);
 
   // Bring up the plugin layer: install the runtime bridge, register the

package/src/daemon/message-protocol.ts

@@ -18,7 +18,6 @@ export * from "./message-types/shared.js";
 export * from "./message-types/skills.js";
 export * from "./message-types/surfaces.js";
 export * from "./message-types/sync.js";
-export * from "./message-types/web-activity.js";
 
 // Client-message domain aliases for the ClientMessage union.
 import type { _ComputerUseClientMessages } from "./message-types/computer-use.js";