@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/daemon/conversation-runtime-assembly.ts

@@ -13,6 +13,7 @@ import {
   getAppDirPath,
   listAppFiles,
   resolveAppDir,
+  resolveAppSource,
 } from "../apps/app-store.js";
 import { type ChannelId, parseInterfaceId } from "../channels/types.js";
 import { resolveDefaultProfileForProvider } from "../config/default-profile-catalog.js";
@@ -433,6 +434,54 @@ export function buildActiveDocuments(conversationId: string): Array<{
     : null;
 }
 
+/**
+ * Resolves the app the client reported as on-screen into the summary the
+ * `unified-turn-context` injector renders as the `visible_app:` line. Returns
+ * `null` when no app is in view or the id no longer resolves to an app (e.g.
+ * it was deleted while open).
+ *
+ * Resolution goes through `resolveAppSource` rather than `getApp` so both id
+ * shapes the viewer can hold are covered: workspace apps (opaque id) and
+ * plugin-bundled apps (`plugins~<plugin>~<app>`), which the apps list and open
+ * routes serve alongside them. Plugin apps carry their owning plugin so the
+ * rendered line can say the source belongs to a plugin rather than reading as
+ * an ordinary sandbox app to rewrite.
+ *
+ * Both identifiers come back: a workspace app's `appId` is an opaque UUID and
+ * the readable handle is its `slug` (the directory stem, frozen at creation).
+ * The app tools key off the id, so the line carries it for tool calls and the
+ * slug for everything a human or the model would recognize.
+ */
+export function buildVisibleAppContext(appId: string | undefined): {
+  appId: string;
+  name: string;
+  slug: string;
+  sourceDir: string;
+  pluginName?: string;
+} | null {
+  if (!appId) {
+    return null;
+  }
+  try {
+    const source = resolveAppSource(appId);
+    if (!source) {
+      return null;
+    }
+    return {
+      appId: source.id,
+      name: source.name,
+      slug: source.dirName,
+      sourceDir: source.sourceDir,
+      ...(source.origin.kind === "plugin"
+        ? { pluginName: source.origin.pluginName }
+        : {}),
+    };
+  } catch {
+    // Malformed id (traversal-shaped, empty): treat as no app in view.
+    return null;
+  }
+}
+
 const MAX_CONTEXT_LENGTH = 100_000;
 
 function truncateHtml(html: string, budget: number): string {
@@ -2195,6 +2244,13 @@ export async function applyRuntimeInjections(
   // `clientOs`) so a queued message from another surface can't perturb the
   // in-flight turn — same anti-race pattern as `clientTimezone`.
   const clientOs = liveConversation?.currentTurnClientOs ?? undefined;
+  // The app the client has on screen (app viewer or the app-editing split),
+  // resolved to its name and source directory so the assistant can act on it
+  // without asking the user which app they mean. Frozen per turn like
+  // `clientOs` for the same anti-race reason.
+  const visibleApp = buildVisibleAppContext(
+    liveConversation?.currentTurnVisibleAppId,
+  );
   const channelName = liveConversation
     ? (liveConversation.currentTurnChannelContext?.userMessageChannel ??
       liveConversation.originChannel ??
@@ -2304,6 +2360,7 @@ export async function applyRuntimeInjections(
     timestamp,
     interfaceName,
     clientOs,
+    visibleApp,
     channelName,
     actorContext: options.actorContext,
     configuredUserTimezone,

package/src/daemon/conversation-store.ts

@@ -51,6 +51,30 @@ import { buildTransportHints } from "./transport-hints.js";
 
 const conversationOptions = new Map<string, ConversationCreateOptions>();
 
+/**
+ * Drops the transport fields that describe what the client had on screen for a
+ * single message rather than for the conversation as a whole.
+ *
+ * `conversationOptions` is a durable map: a rebuilt conversation (evicted or
+ * gone stale) re-applies whatever transport was stored the last time anyone
+ * touched it. View state must not survive that, or a scheduled wake hours
+ * later would resurrect an app the user has since closed and assert it is on
+ * screen. The current call still applies the full transport to the live
+ * conversation, so only the persisted copy is trimmed.
+ */
+export function withoutTurnScopedTransport(
+  options: ConversationCreateOptions,
+): ConversationCreateOptions {
+  const transport = options.transport;
+  if (!transport || transport.visibleAppId === undefined) {
+    return options;
+  }
+  return {
+    ...options,
+    transport: { ...transport, visibleAppId: undefined },
+  };
+}
+
 export function mergeConversationOptions(
   conversationId: string,
   patch: Partial<ConversationCreateOptions>,
@@ -86,6 +110,7 @@ function applyTransportMetadata(
   conversation.applyHostEnvFromTransport(transport);
   conversation.applyClientTimezoneFromTransport(transport);
   conversation.applyClientOsFromTransport(transport);
+  conversation.applyVisibleAppFromTransport(transport);
 }
 
 /**
@@ -110,7 +135,10 @@ export async function getOrCreateConversation(
     ...persistentOptions
   } = options ?? {};
   if (Object.values(persistentOptions).some((v) => v !== undefined)) {
-    mergeConversationOptions(conversationId, persistentOptions);
+    mergeConversationOptions(
+      conversationId,
+      withoutTurnScopedTransport(persistentOptions),
+    );
   }
 
   if (
@@ -221,6 +249,13 @@ export async function getOrCreateConversation(
         await newConversation.ensureActorScopedHistory();
       }
       applyTransportMetadata(newConversation, storedOptions);
+      // The stored transport is stripped of view state, so a rebuild driven by
+      // a live send takes the app on screen from THIS call. A rebuild with no
+      // inbound transport (a scheduled wake, a background follow-up) correctly
+      // leaves it unset rather than inheriting whatever was open last time.
+      if (options?.transport) {
+        newConversation.applyVisibleAppFromTransport(options.transport);
+      }
       setConversation(conversationId, newConversation);
       return newConversation;
     })();

package/src/daemon/conversation-surfaces.ts

@@ -13,6 +13,7 @@ import {
   isKnownSurfaceType,
   MODEL_INVOKABLE_SURFACE_TYPES,
   normalizeCopyBlockShowData,
+  normalizeVisualShowData,
   OAuthConnectSurfaceDataSchema,
   safeParseSurfaceData,
   SurfaceTypeSchema,
@@ -98,6 +99,33 @@ import type { HostAppControlInput } from "./message-types/host-app-control.js";
 import type { UserMessageAttachment } from "./message-types/shared.js";
 import type { TrustContext } from "./trust-context-types.js";
 
+/**
+ * Prefix of the synthetic user-message text this module writes when a surface
+ * action has no custom prompt of its own (`[User action on app: ...]`,
+ * `[User action on <surface_type> surface: ...]`).
+ *
+ * Machine-authored, so turns carrying it must be stamped `scripted` and kept
+ * out of activation counts. Deliberately the SAME anchor the analytics
+ * classifier matches on (`stg_telemetry__scripted_turn.sql`, "Synthetic
+ * UI-surface action events"): the two signals are compared against each other
+ * by the `assert_scripted_signals_agree` dbt test, so if this string ever
+ * changes, that model's anchor has to change with it or the test fires.
+ */
+const SYNTHETIC_SURFACE_ACTION_PREFIX = "[User action on ";
+
+/**
+ * True when `content` is the synthetic fallback text above rather than a
+ * custom prompt supplied by the surface.
+ *
+ * Only the synthetic form is scripted. A surface that supplies its own prompt
+ * is treated as a real turn, because that is what the existing analytics
+ * classifier does. Widening this to every surface action would silently move
+ * activation beyond the bug being fixed.
+ */
+function isSyntheticSurfaceActionContent(content: string): boolean {
+  return content.startsWith(SYNTHETIC_SURFACE_ACTION_PREFIX);
+}
+
 const log = getLogger("conversation-surfaces");
 
 // Tolerant variant of SurfaceActionSchema for parsing raw model output.
@@ -112,6 +140,16 @@ const ModelActionSchema = SurfaceActionSchema.extend({
 
 const MAX_UNDO_DEPTH = 10;
 
+/**
+ * Pending surface types that do not hold the one-interactive-surface-at-a-time
+ * lock. Both render content the user reads rather than a question they must
+ * answer, so a live one must not block the next surface.
+ */
+const NON_BLOCKING_PENDING_SURFACE_TYPES = new Set<SurfaceType>([
+  "dynamic_page",
+  "visual",
+]);
+
 /**
  * Debounce window for persisting `ui_surface_update` data back to the
  * message row. Surfaces typically receive bursts of updates (e.g. a
@@ -2012,6 +2050,9 @@ export async function handleSurfaceAction(
       activeSurfaceId: surfaceId,
       displayContent,
       sourceActorPrincipalId,
+      // Rides the metadata bag rather than a typed option: the queue
+      // round-trips `metadata` but not `PersistMessageOptions`.
+      metadata: { scripted: isSyntheticSurfaceActionContent(content) },
     });
 
     if (result.rejected) {
@@ -2069,6 +2110,7 @@ export async function handleSurfaceAction(
         activeSurfaceId: surfaceId,
         displayContent,
         sourceActorPrincipalId,
+        scripted: isSyntheticSurfaceActionContent(content),
       })
       .catch((err) => {
         const message = err instanceof Error ? err.message : String(err);
@@ -2254,6 +2296,9 @@ export async function handleSurfaceAction(
     activeSurfaceId: surfaceId,
     displayContent,
     sourceActorPrincipalId,
+    // Rides the metadata bag rather than a typed option: the queue
+    // round-trips `metadata` but not `PersistMessageOptions`.
+    metadata: { scripted: isSyntheticSurfaceActionContent(content) },
   });
   if (result.rejected) {
     ctx.surfaceActionRequestIds.delete(requestId);
@@ -2336,6 +2381,7 @@ export async function handleSurfaceAction(
       activeSurfaceId: surfaceId,
       displayContent,
       sourceActorPrincipalId,
+      scripted: isSyntheticSurfaceActionContent(content),
     })
     .catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
@@ -2992,9 +3038,9 @@ export async function surfaceProxyResolver(
     }
 
     // Every surface type parses through its canonical schema. Card,
-    // copy_block, and dynamic_page first run bespoke normalizers that
-    // recover fields the model placed at the top level of the tool input;
-    // the rest go straight through `safeParseSurfaceData`. Choice and
+    // copy_block, dynamic_page, and visual first run bespoke normalizers
+    // that recover fields the model placed at the top level of the tool
+    // input; the rest go straight through `safeParseSurfaceData`. Choice and
     // oauth_connect parse into named bindings so their content guards below
     // read typed data instead of re-narrowing the union.
     const cardData =
@@ -3026,7 +3072,12 @@ export async function surfaceProxyResolver(
                     surfaceType,
                     data: normalizeDynamicPageShowData(input, rawData),
                   }
-                : parseShowPairOrThrow(surfaceType, rawData);
+                : surfaceType === "visual"
+                  ? {
+                      surfaceType,
+                      data: normalizeVisualShowData(input, rawData),
+                    }
+                  : parseShowPairOrThrow(surfaceType, rawData);
     // Parse actions through the schema instead of typecasting raw model output.
     // The model may place actions inside `data` instead of the top-level
     // `actions` param — recover them so they aren't silently dropped.
@@ -3103,10 +3154,12 @@ export async function surfaceProxyResolver(
 
     // Only one non-persistent interactive surface at a time. If another
     // surface is already awaiting user input, reject this one so the LLM
-    // presents surfaces sequentially.
+    // presents surfaces sequentially. dynamic_page and visual are rendered
+    // content rather than a question posed to the user, so a pending one
+    // never blocks the next surface.
     if (awaitAction) {
       const hasExistingPending = [...ctx.pendingSurfaceActions.values()].some(
-        (entry) => entry.surfaceType !== "dynamic_page",
+        (entry) => !NON_BLOCKING_PENDING_SURFACE_TYPES.has(entry.surfaceType),
       );
       if (hasExistingPending) {
         return {
@@ -3215,6 +3268,15 @@ export async function surfaceProxyResolver(
         yieldToUser: true,
       };
     }
+    if (surfaceType === "visual") {
+      return {
+        content: JSON.stringify({
+          surfaceId,
+          note: "The visual is now visible inline in the chat. Continue your response in prose and do not describe or restate what the visual shows. To replace it, call ui_dismiss with this surfaceId and show a new one.",
+        }),
+        isError: false,
+      };
+    }
     return { content: JSON.stringify({ surfaceId }), isError: false };
   }
 

package/src/daemon/conversation-turn-finalize.ts

@@ -22,8 +22,10 @@ import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
 } from "../context/post-turn-tool-result-truncation.js";
+import { emitAssistantReplyNotification } from "../notifications/assistant-reply-producer.js";
 import { projectAssistantMessage } from "../persistence/conversation-attention-store.js";
 import {
+  type ConversationRow,
   getConversation,
   getMessageById,
   parseMessageMetadata,
@@ -142,12 +144,44 @@ export async function runDeferredTurnTail(params: {
   state: TurnTailState;
   rlog: pino.Logger;
   generationCompletedAt: number;
+  /**
+   * True only for a `message_complete` turn that produced a genuine reply. A
+   * handed-off generation is not the end of the run, a cancelled one has no
+   * final reply, and a provider-error turn's only assistant row is the
+   * synthetic error text.
+   */
+  turnCompleted: boolean;
+  /** Id of the row that opened this turn, for the notification producer. */
+  userMessageId: string | undefined;
+  /**
+   * True when this turn's reply streams to the app and nowhere else, for the
+   * notification producer's delivery-surface gates.
+   */
+  replyDeliveredInAppOnly?: boolean;
 }): Promise<void> {
-  const { ctx, state, rlog, generationCompletedAt } = params;
+  const {
+    ctx,
+    state,
+    rlog,
+    generationCompletedAt,
+    turnCompleted,
+    userMessageId,
+    replyDeliveredInAppOnly,
+  } = params;
   const tailStartedAt = Date.now();
 
+  // Conversation row for the notification producer below. Guarded like every
+  // step below, because this runs after the terminal SSE and a SQLite hiccup
+  // must not escape into the loop's outer catch.
+  let conversation: ConversationRow | null = null;
+  try {
+    conversation = getConversation(ctx.conversationId);
+  } catch (err) {
+    rlog.warn({ err }, "Failed to read conversation for end-of-turn work");
+  }
+
   // Per-message memory/attention finalize side-effects deferred from
-  // `handleMessageComplete` — one closure per assistant row produced this turn,
+  // `handleMessageComplete`: one closure per assistant row produced this turn,
   // in production order.
   for (const effect of state.deferredFinalizeEffects) {
     try {
@@ -157,16 +191,44 @@ export async function runDeferredTurnTail(params: {
     }
   }
 
+  // Notify about a finished reply the user is no longer looking at. Ordered
+  // after the loop above so the producer's unseen check reads the attention
+  // cursor this turn's last row just projected. Not awaited: the pipeline
+  // awaits the platform adapter's HTTP dispatch, which retries with backoff,
+  // and nothing below here depends on the emit. The producer never rejects.
+  if (turnCompleted && state.lastAssistantMessageId) {
+    void emitAssistantReplyNotification({
+      conversationId: ctx.conversationId,
+      assistantMessageId: state.lastAssistantMessageId,
+      userMessageId,
+      ...(replyDeliveredInAppOnly ? { replyDeliveredInAppOnly: true } : {}),
+      rlog,
+      conversation,
+    });
+  }
+
+  // Fresh row for the two filesystem steps below. The awaited work above is
+  // long enough for the user to delete the conversation, and the row read at
+  // the top of the tail stays truthy across that deletion, so spooling or
+  // mirroring against it would rebuild a deleted conversation's directory from
+  // in-memory history. A row that is gone skips both steps exactly as an
+  // unreadable one does.
+  let liveConversation: ConversationRow | null = null;
+  try {
+    liveConversation = getConversation(ctx.conversationId);
+  } catch (err) {
+    rlog.warn({ err }, "Failed to re-read conversation for end-of-turn work");
+  }
+
   // Post-turn tool-result truncation: spool oversized results to disk and
   // replace their in-context content with a stub + pointer, shrinking the next
   // turn's context. Rewrites only the in-memory history, so it has no bearing on
   // the reply already delivered to the client.
   try {
-    const conv = getConversation(ctx.conversationId);
-    if (conv) {
+    if (liveConversation) {
       const convDir = getResolvedConversationDirPath(
         ctx.conversationId,
-        conv.createdAt,
+        liveConversation.createdAt,
       );
       const { messages: derefMessages, dereferencedCount } =
         derefToolResultReReads(ctx.messages);
@@ -199,20 +261,16 @@ export async function runDeferredTurnTail(params: {
   }
 
   // Mirror the final assistant row into the JSONL disk view. Guarded like the
-  // steps above: this runs AFTER the terminal SSE, so a throw here (e.g. a
-  // SQLite read failure in `getConversation`) must not escape into the loop's
-  // outer catch and emit a second, contradictory terminal event for a turn the
-  // client already saw complete.
+  // steps above: this runs AFTER the terminal SSE, so a throw here must not
+  // escape into the loop's outer catch and emit a second, contradictory
+  // terminal event for a turn the client already saw complete.
   try {
-    if (state.lastAssistantMessageId) {
-      const convForDisk = getConversation(ctx.conversationId);
-      if (convForDisk) {
-        syncMessageToDisk(
-          ctx.conversationId,
-          state.lastAssistantMessageId,
-          convForDisk.createdAt,
-        );
-      }
+    if (state.lastAssistantMessageId && liveConversation) {
+      syncMessageToDisk(
+        ctx.conversationId,
+        state.lastAssistantMessageId,
+        liveConversation.createdAt,
+      );
     }
   } catch (err) {
     rlog.warn({ err }, "Failed to sync assistant message to disk (non-fatal)");

package/src/daemon/conversation.ts

@@ -622,6 +622,23 @@ export class Conversation {
    * @internal
    */
   currentTurnClientOs?: string;
+  /**
+   * @internal
+   * Id of the app the client currently has open on screen, reported by the
+   * client on each message. Drives the per-turn `visible_app:` context line so
+   * the assistant can resolve "the app" to what the user is looking at. This
+   * is the LIVE value; the assembly reads the frozen
+   * {@link currentTurnVisibleAppId}.
+   */
+  visibleAppId?: string;
+  /**
+   * Per-turn frozen copy of {@link visibleAppId}, captured by the agent loop at
+   * turn start for the same reason as {@link currentTurnClientOs}: a queued
+   * message sent from a different view re-applies transport metadata before it
+   * is enqueued, and must not swap the app under the in-flight turn.
+   * @internal
+   */
+  currentTurnVisibleAppId?: string;
   /**
    * Per-turn temporal snapshot frozen by the agent loop and read by
    * `applyRuntimeInjections` to build the `<turn_context>` timezone-mismatch
@@ -1957,26 +1974,64 @@ export class Conversation {
     }
   }
 
-  async forceCompact(): Promise<ContextWindowResult> {
-    // Report the user-facing before/after using the provider's real tokenizer
-    // (count_tokens) so the `/compact` line matches the context-window
-    // indicator, which reflects the provider's actual reported usage — rather
-    // than the local chars/4 estimate the compaction pipeline runs internally
-    // (it under-counts by ~25% on typical histories). `calculateTokens`
-    // falls back to that estimate when the provider has no count endpoint or
-    // the count call fails, so behavior degrades gracefully.
-    //
-    // Only the *displayed* numbers are overridden — the compaction log and
-    // circuit-breaker accounting inside `runCompaction` keep the estimate-based
-    // figures, leaving calibration and historical logs untouched.
+  /**
+   * Push the conversation's current context-window usage to clients so the
+   * context-window indicator matches the numbers a user-initiated compaction
+   * card reports. Turn-driven compaction needs no push: the turn's own
+   * `usage_update` carries the post-compaction count.
+   *
+   * Defaults to the conversation's own sender, the channel `emitActivityState`
+   * and `context_compacted` already use, so a queued `/compact` reaches the
+   * same client its result card does. Routes that resolve a conversation
+   * outside the send path never wire that sender and pass their own `onEvent`.
+   */
+  private emitContextWindowUsage(
+    tokens: number,
+    maxTokens: number,
+    onEvent?: (msg: AssistantEvent) => void,
+  ): void {
+    try {
+      (onEvent ?? this.sendToClient)({
+        type: "context_window_usage",
+        conversationId: this.conversationId,
+        tokens,
+        maxTokens,
+      });
+    } catch (err) {
+      log.warn(
+        { err, conversationId: this.conversationId },
+        "sendToClient threw in emitContextWindowUsage",
+      );
+    }
+  }
+
+  /**
+   * Run a user-initiated compaction (`run`), reporting its before/after with
+   * the provider's real tokenizer (count_tokens) rather than the local chars/4
+   * estimate the compaction pipeline runs internally (it under-counts by ~25%
+   * on typical histories), and pushing the resulting count to clients.
+   * `calculateTokens` falls back to that estimate when the provider has no
+   * count endpoint or the count call fails, so behavior degrades gracefully.
+   *
+   * Only the *displayed* numbers are overridden: the compaction log and
+   * circuit-breaker accounting inside `runCompaction` keep the estimate-based
+   * figures, leaving calibration and historical logs untouched.
+   *
+   * `run` must leave the compacted history applied to `this.messages`, which
+   * every `runCompaction` path does. `onEvent` overrides the sink the usage
+   * push goes to.
+   */
+  private async runUserCompaction(
+    run: () => Promise<ContextWindowResult>,
+    onEvent?: (msg: AssistantEvent) => void,
+  ): Promise<ContextWindowResult> {
     const before = await this.calculateTokens(this.messages);
-    const result = await this.runCompaction(true);
-    // `runCompaction` applies the compacted history to `this.messages` in
-    // place, so after a successful compaction this re-counts the new history;
-    // a no-op leaves the context unchanged, so before === after.
+    const result = await run();
+    // A no-op leaves the context unchanged, so before === after.
     const after = result.compacted
       ? await this.calculateTokens(this.messages)
       : before;
+    this.emitContextWindowUsage(after, result.maxInputTokens, onEvent);
     return {
       ...result,
       previousEstimatedInputTokens: before,
@@ -1984,6 +2039,20 @@ export class Conversation {
     };
   }
 
+  /**
+   * `/compact`. `onEvent` is the sink for the context-window usage push, and
+   * callers pass whatever sink they render the result card through: the queue
+   * drain carries the queued item's own `onEvent`, and `sendToClient` is reset
+   * to a no-op once an interactive turn finishes (`process-message.ts`), so a
+   * `/compact` draining behind that turn would otherwise push into nothing
+   * while its card still reaches the client.
+   */
+  async forceCompact(
+    onEvent?: (msg: AssistantEvent) => void,
+  ): Promise<ContextWindowResult> {
+    return this.runUserCompaction(() => this.runCompaction(true), onEvent);
+  }
+
   /**
    * "Summarize up to here": summarize everything before the turn containing
    * `beforeMessageId`, keeping that turn and everything after it verbatim.
@@ -1996,9 +2065,15 @@ export class Conversation {
    * `resolveMetaSlashCommand`. Throws {@link UserError} (messages are
    * user-facing) when the boundary cannot be resolved or the row→history
    * index mapping cannot be verified.
+   *
+   * `onEvent` is the sink for the context-window usage push. The management
+   * route that owns this action resolves its conversation outside the send
+   * path, so the instance can still hold the store's no-op sender; it passes
+   * the same broadcast path its result card goes out on.
    */
   async summarizeUpToMessage(
     beforeMessageId: string,
+    onEvent?: (msg: AssistantEvent) => void,
   ): Promise<ContextWindowResult> {
     const priorTrustContext = this.trustContext;
     if (!resolveCapabilities(priorTrustContext?.trustClass).canAccessMemory) {
@@ -2078,17 +2153,22 @@ export class Conversation {
           firstRowByHistoryIndex[historyIndex] = rowIndex;
         }
       }
-      return await this.runCompaction(true, undefined, {
-        fixedTailStartIndex: tailIndex,
-        // When repair merged preceding continuation rows into the boundary's
-        // message, the row boundary retreats to the message's first
-        // contributing row: the summary call reads messages[0..tailIndex),
-        // which excludes the merged rows' content, so the image manifest and
-        // watermarks must not treat them as summarized.
-        fixedBoundaryRowIndex:
-          firstRowByHistoryIndex[tailIndex] ?? boundaryRowIndex,
-        fixedBoundaryRowView: { rows, firstRowByHistoryIndex },
-      });
+      return await this.runUserCompaction(
+        () =>
+          this.runCompaction(true, undefined, {
+            fixedTailStartIndex: tailIndex,
+            // When repair merged preceding continuation rows into the
+            // boundary's message, the row boundary retreats to the message's
+            // first contributing row: the summary call reads
+            // messages[0..tailIndex), which excludes the merged rows' content,
+            // so the image manifest and watermarks must not treat them as
+            // summarized.
+            fixedBoundaryRowIndex:
+              firstRowByHistoryIndex[tailIndex] ?? boundaryRowIndex,
+            fixedBoundaryRowView: { rows, firstRowByHistoryIndex },
+          }),
+        onEvent,
+      );
     } finally {
       // Only undo the temporary guardian context this method installed. If
       // trustContext was legitimately updated at an `await` boundary, the
@@ -2398,6 +2478,10 @@ export class Conversation {
     this.clientOs = transport.clientOs ?? undefined;
   }
 
+  applyVisibleAppFromTransport(transport: ConversationTransportMetadata): void {
+    this.visibleAppId = transport.visibleAppId ?? undefined;
+  }
+
   setAssistantId(assistantId: string | null): void {
     this.assistantId = assistantId ?? undefined;
   }
@@ -2471,6 +2555,17 @@ export class Conversation {
       titleText?: string;
       /** See {@link runAgentLoopImpl} — hidden machine-signal turn marker. */
       isHiddenPrompt?: boolean;
+      /**
+       * See {@link runAgentLoopImpl}: the row the end-of-turn reply
+       * notification treats as the prompt this turn answers.
+       */
+      notifyUserMessageId?: string;
+      /**
+       * See {@link runAgentLoopImpl}: this run's reply streams to the app
+       * alone, so the reply notification ignores the initiating row's
+       * channel/voice delivery markers.
+       */
+      replyDeliveredInAppOnly?: boolean;
       callSite?: LLMCallSite;
       /**
        * Optional ad-hoc inference-profile override applied to every LLM call

package/src/daemon/lifecycle.ts

@@ -28,6 +28,7 @@ import { initializeDb } from "../persistence/db-init.js";
 import { startEmbeddingRuntimeManager } from "../persistence/embeddings/embedding-backend.js";
 import { maybeEnqueueLexicalBackfillOnUpgrade } from "../persistence/job-handlers/message-lexical-backfill.js";
 import { clearLifecycleQuiesce } from "../persistence/lifecycle-quiesce.js";
+import { isPlatformClientConfigured } from "../platform/client.js";
 import { startConsentRefresh } from "../platform/consent-cache.js";
 import { syncWorkspaceIdentityToPlatform } from "../platform/sync-identity.js";
 import { ensurePromptFiles } from "../prompts/system-prompt.js";
@@ -198,6 +199,14 @@ export async function runDaemon(): Promise<void> {
   // failure is non-fatal — the daemon falls back to IPC-only operation.
   await startRuntimeHttpServer();
 
+  // Warms the configured-probe cache (credential reads only, no DB). Fired
+  // immediately after the transport binds, ahead of DB init and readiness,
+  // so an urgent signal arriving the moment requests are admitted is not
+  // decided on an empty cache.
+  void isPlatformClientConfigured().catch((err) =>
+    log.warn({ err }, "Platform configured-probe warmup failed"),
+  );
+
   // Pre-populate feature flag overrides so subsequent sync
   // isAssistantFeatureFlagEnabled() calls have data. Fired non-blocking
   // so a slow or unreachable gateway doesn't delay daemon startup (the