@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/runtime/routes/conversation-routes.ts

@@ -116,6 +116,7 @@ import {
   isConversationProcessing,
   isHiddenMessageMetadata,
   isProviderErrorMetadata,
+  isSuppressedQueuedMessage,
   isSystemCardMetadata,
   type MessageRow,
   recordConversationPersistedSeq,
@@ -172,6 +173,7 @@ import {
   emitCannedMessageComplete,
   persistCannedAssistantCard,
 } from "./canned-message-complete.js";
+import { scheduleCannedReplyRelease } from "./canned-reply-release.js";
 import { buildChannelMetadata } from "./channel-metadata.js";
 import {
   BadRequestError,
@@ -639,7 +641,7 @@ async function tryConsumeGuardianReply(params: {
       attachments,
     });
 
-    const cleanUserMessage = createUserMessage(content, attachments);
+    const cleanUserMessage = await createUserMessage(content, attachments);
     const llmUserMessage = enrichMessageWithSourcePaths(
       cleanUserMessage,
       attachments,
@@ -691,6 +693,68 @@ async function tryConsumeGuardianReply(params: {
   return { consumed: true, messageId };
 }
 
+/**
+ * Read the notification discriminators a client uses to keep daemon-injected
+ * rows out of the rendered transcript off a message's parsed metadata.
+ *
+ * One extraction shared by the persisted-history rows and the queued rows
+ * synthesized from the in-memory queue, so a row carries the same flags
+ * whichever side of the drain it is fetched from.
+ */
+function extractNotificationDiscriminators(
+  meta: Record<string, unknown>,
+): Pick<
+  ConversationMessage,
+  "subagentNotification" | "acpNotification" | "backgroundEventNotification"
+> {
+  const discriminators: Pick<
+    ConversationMessage,
+    "subagentNotification" | "acpNotification" | "backgroundEventNotification"
+  > = {};
+
+  // Every wake persists a `<background_event source="...">` trigger row
+  // (see `persistWakeTriggerMessage`) that the LLM reads. Flag any such
+  // row so clients hide it from the transcript like a subagent/ACP
+  // notification: the user-facing "Conversation Woke" card (or, for a
+  // backgrounded bash run, the inline terminal card) carries the status.
+  if (isBackgroundEventMetadata(meta)) {
+    discriminators.backgroundEventNotification = true;
+  }
+
+  const subagent = meta.subagentNotification as
+    | Record<string, unknown>
+    | undefined;
+  if (
+    subagent &&
+    typeof subagent.subagentId === "string" &&
+    typeof subagent.label === "string"
+  ) {
+    discriminators.subagentNotification = {
+      subagentId: subagent.subagentId,
+      label: subagent.label,
+      status:
+        typeof subagent.status === "string" ? subagent.status : "completed",
+      ...(typeof subagent.error === "string" ? { error: subagent.error } : {}),
+      ...(typeof subagent.conversationId === "string"
+        ? { conversationId: subagent.conversationId }
+        : {}),
+      ...(typeof subagent.objective === "string"
+        ? { objective: subagent.objective }
+        : {}),
+    };
+  }
+
+  const acp = meta.acpNotification as Record<string, unknown> | undefined;
+  if (acp && typeof acp.acpSessionId === "string") {
+    discriminators.acpNotification = {
+      acpSessionId: acp.acpSessionId,
+      ...(typeof acp.agent === "string" ? { agent: acp.agent } : {}),
+    };
+  }
+
+  return discriminators;
+}
+
 /**
  * Render the live conversation's in-memory message queue into history rows.
  *
@@ -713,12 +777,17 @@ function buildQueuedMessagePayloads(
     return [];
   }
 
-  // Hidden sends are suppressed from the transcript at every stage — echo,
-  // persisted row, and here the in-memory queue window: a latest-page fetch
-  // while the item still awaits drain must not surface it as a queued bubble.
+  // Rows that never render as a user bubble are suppressed at every stage —
+  // echo, persisted row, and here the in-memory queue window: a latest-page
+  // fetch while the item still awaits drain must not surface it as a queued
+  // bubble. That covers hidden sends and the daemon's own injected
+  // notifications (a subagent's completion summary enqueued into a busy
+  // parent, an ACP run outcome, a wake trigger) — the user follows those
+  // through their inline cards, never as a queued message they could steer or
+  // cancel.
   return conversation
     .snapshotQueuedMessages()
-    .filter((item) => !isHiddenMessageMetadata(item.metadata))
+    .filter((item) => !isSuppressedQueuedMessage(item.metadata))
     .map((item, index) => {
       const text = item.displayContent ?? item.content;
       const attachments: RuntimeAttachmentMetadata[] = item.attachments.map(
@@ -755,15 +824,19 @@ function buildQueuedMessagePayloads(
         ...(item.clientMessageId
           ? { clientMessageId: item.clientMessageId }
           : {}),
+        // The filter above already drops every daemon-injected notification,
+        // so these flags are redundant today. Carrying them keeps a queued row
+        // self-describing on the wire, matching its persisted counterpart.
+        ...extractNotificationDiscriminators(item.metadata ?? {}),
         queueStatus: "queued" as const,
         queuePosition: index + 1,
       };
     });
 }
 
-export function handleListMessages({
+export async function handleListMessages({
   queryParams,
-}: RouteHandlerArgs): Record<string, unknown> {
+}: RouteHandlerArgs): Promise<Record<string, unknown>> {
   const conversationId = queryParams?.conversationId;
   const conversationKey = queryParams?.conversationKey;
 
@@ -920,23 +993,14 @@ export function handleListMessages({
     // was queued or its persistence was delayed (long assistant generation),
     // sentAt captures the actual event time. Falls back to createdAt.
     let sentAt: number | undefined;
-    let subagentNotification:
-      | {
-          subagentId: string;
-          label: string;
-          status: string;
-          error?: string;
-          conversationId?: string;
-        }
-      | undefined;
-    let acpNotification: { acpSessionId: string; agent?: string } | undefined;
-    let backgroundEventNotification: boolean | undefined;
+    let notifications: ReturnType<typeof extractNotificationDiscriminators> =
+      {};
     let backgroundToolCompletion: ConversationMessage["backgroundToolCompletion"];
     let systemCard: boolean | undefined;
     let providerError: ConversationMessage["providerError"];
     if (msg.metadata) {
       try {
-        const meta = JSON.parse(msg.metadata);
+        const meta = JSON.parse(msg.metadata) as Record<string, unknown>;
         if (typeof meta.sentAt === "number") {
           sentAt = meta.sentAt;
         }
@@ -958,14 +1022,7 @@ export function handleListMessages({
               : {}),
           };
         }
-        // Every wake persists a `<background_event source="...">` trigger row
-        // (see `persistWakeTriggerMessage`) that the LLM reads. Flag any such
-        // row so clients hide it from the transcript like a subagent/ACP
-        // notification — the user-facing "Conversation Woke" card (or, for a
-        // backgrounded bash run, the inline terminal card) carries the status.
-        if (isBackgroundEventMetadata(meta)) {
-          backgroundEventNotification = true;
-        }
+        notifications = extractNotificationDiscriminators(meta);
         // `persistWakeTriggerMessage` stamps the structured completion onto the
         // same wake row, letting the web rebuild a terminal inline card from
         // history after a restart (the in-memory completed ring does not survive).
@@ -975,32 +1032,6 @@ export function handleListMessages({
         if (completionParse.success) {
           backgroundToolCompletion = completionParse.data;
         }
-        if (meta.subagentNotification) {
-          const n = meta.subagentNotification;
-          if (typeof n.subagentId === "string" && typeof n.label === "string") {
-            subagentNotification = {
-              subagentId: n.subagentId,
-              label: n.label,
-              status: typeof n.status === "string" ? n.status : "completed",
-              ...(typeof n.error === "string" ? { error: n.error } : {}),
-              ...(typeof n.conversationId === "string"
-                ? { conversationId: n.conversationId }
-                : {}),
-              ...(typeof n.objective === "string"
-                ? { objective: n.objective }
-                : {}),
-            };
-          }
-        }
-        if (meta.acpNotification) {
-          const n = meta.acpNotification;
-          if (typeof n.acpSessionId === "string") {
-            acpNotification = {
-              acpSessionId: n.acpSessionId,
-              ...(typeof n.agent === "string" ? { agent: n.agent } : {}),
-            };
-          }
-        }
       } catch {
         // Ignore malformed metadata
       }
@@ -1025,9 +1056,9 @@ export function handleListMessages({
       content,
       createdAt: msg.createdAt,
       sentAt,
-      subagentNotification,
-      acpNotification,
-      backgroundEventNotification,
+      subagentNotification: notifications.subagentNotification,
+      acpNotification: notifications.acpNotification,
+      backgroundEventNotification: notifications.backgroundEventNotification,
       backgroundToolCompletion,
       systemCard,
       providerError,
@@ -1046,196 +1077,207 @@ export function handleListMessages({
   );
   const pendingQuestions = collectPendingQuestions(resolvedConversationId);
 
-  const messages: RuntimeMessagePayload[] = parsed.map((m) => {
-    const mergedMessageIds = m.id ? (mergedIdMap.get(m.id) ?? []) : [];
-
-    // Hydrate the row's attachments from the DB. A metadata-only query avoids
-    // loading large base64 blobs for non-image attachments (documents, audio);
-    // full data is fetched only for images so the client can generate
-    // thumbnails for inline display on history restore. Merged messages
-    // (consecutive assistant merge) are queried too so their attachments
-    // aren't lost before DB compaction relinks them.
-    let msgAttachments: RuntimeAttachmentMetadata[] = [];
-    if (m.id) {
-      const idsToQuery = [m.id, ...mergedMessageIds];
-      const linked = idsToQuery.flatMap((id) =>
-        getAttachmentMetadataForMessage(id),
-      );
-      if (linked.length > 0) {
-        msgAttachments = linked.map((a) => {
-          // Hydrate image rows for inline thumbnails. Legacy HEIC can be
-          // stored under application/octet-stream (empty File.type fallback),
-          // so `.heic`/`.heif` rows are hydrated by filename too;
-          // normalizeImageBase64 sniffs the bytes and rewrites only genuine
-          // HEIF, which Chromium-based clients cannot decode. Filename and
-          // sizeBytes keep describing the stored original, which
-          // /attachments/:id/content serves verbatim for downloads.
-          const isImage = a.mimeType.startsWith("image/");
-          const isLegacyHeic = !isImage && isHeicFilename(a.originalFilename);
-          const full =
-            isImage || isLegacyHeic
-              ? getAttachmentById(a.id, { hydrateFileData: true })
-              : null;
-          const display = full?.dataBase64
-            ? normalizeImageBase64(a.mimeType, full.dataBase64)
-            : null;
-          // Image rows carry data even when unconverted (thumbnails); a
-          // non-image row only becomes renderable once conversion yields a
-          // JPEG, so it stays metadata-only when conversion is unavailable.
-          const useDisplay =
-            display && (isImage || display.converted) ? display : null;
-          return {
-            id: a.id,
-            filename: a.originalFilename,
-            mimeType: useDisplay?.mimeType ?? a.mimeType,
-            sizeBytes: a.sizeBytes,
-            kind: useDisplay?.converted
-              ? classifyKind(useDisplay.mimeType)
-              : a.kind,
-            ...(useDisplay ? { data: useDisplay.dataBase64 } : {}),
-            ...(a.thumbnailBase64 ? { thumbnailData: a.thumbnailBase64 } : {}),
-            fileBacked: true,
-          };
-        });
+  const messages: RuntimeMessagePayload[] = await Promise.all(
+    parsed.map(async (m) => {
+      const mergedMessageIds = m.id ? (mergedIdMap.get(m.id) ?? []) : [];
+
+      // Hydrate the row's attachments from the DB. A metadata-only query avoids
+      // loading large base64 blobs for non-image attachments (documents, audio);
+      // full data is fetched only for images so the client can generate
+      // thumbnails for inline display on history restore. Merged messages
+      // (consecutive assistant merge) are queried too so their attachments
+      // aren't lost before DB compaction relinks them.
+      let msgAttachments: RuntimeAttachmentMetadata[] = [];
+      if (m.id) {
+        const idsToQuery = [m.id, ...mergedMessageIds];
+        const linked = idsToQuery.flatMap((id) =>
+          getAttachmentMetadataForMessage(id),
+        );
+        if (linked.length > 0) {
+          msgAttachments = await Promise.all(
+            linked.map(async (a) => {
+              // Hydrate image rows for inline thumbnails. Legacy HEIC can be
+              // stored under application/octet-stream (empty File.type fallback),
+              // so `.heic`/`.heif` rows are hydrated by filename too;
+              // normalizeImageBase64 sniffs the bytes and rewrites only genuine
+              // HEIF, which Chromium-based clients cannot decode. Filename and
+              // sizeBytes keep describing the stored original, which
+              // /attachments/:id/content serves verbatim for downloads.
+              const isImage = a.mimeType.startsWith("image/");
+              const isLegacyHeic =
+                !isImage && isHeicFilename(a.originalFilename);
+              const full =
+                isImage || isLegacyHeic
+                  ? getAttachmentById(a.id, { hydrateFileData: true })
+                  : null;
+              const display = full?.dataBase64
+                ? await normalizeImageBase64(a.mimeType, full.dataBase64)
+                : null;
+              // Image rows carry data even when unconverted (thumbnails); a
+              // non-image row only becomes renderable once conversion yields a
+              // JPEG, so it stays metadata-only when conversion is unavailable.
+              const useDisplay =
+                display && (isImage || display.converted) ? display : null;
+              return {
+                id: a.id,
+                filename: a.originalFilename,
+                mimeType: useDisplay?.mimeType ?? a.mimeType,
+                sizeBytes: a.sizeBytes,
+                kind: useDisplay?.converted
+                  ? classifyKind(useDisplay.mimeType)
+                  : a.kind,
+                ...(useDisplay ? { data: useDisplay.dataBase64 } : {}),
+                ...(a.thumbnailBase64
+                  ? { thumbnailData: a.thumbnailBase64 }
+                  : {}),
+                fileBacked: true,
+              };
+            }),
+          );
+        }
       }
-    }
 
-    // Align the hydrated rows with the file-block refs, then render. Rendering
-    // after alignment lets renderHistoryContent inline each `attachment` block
-    // during its single content walk, so `contentBlocks` comes back ready to
-    // ship with no post-processing. The aligned reorder/rewrite keeps the
-    // legacy `attachments` array and `contentOrder` positions consistent.
-    const attachmentRefs = collectAttachmentRefs(m.content);
-    const aligned = alignAttachments(attachmentRefs, msgAttachments);
-    msgAttachments = aligned.attachments;
-    const attachmentBlocks = attachmentRefs.map((_ref, refIdx) => {
-      const att = aligned.refIndexToAttachment.get(refIdx);
-      return att ? toAttachmentBlockRef(att) : null;
-    });
-    const rendered = renderHistoryContent(
-      m.content,
-      attachmentBlocks,
-      m.id ?? undefined,
-    );
+      // Align the hydrated rows with the file-block refs, then render. Rendering
+      // after alignment lets renderHistoryContent inline each `attachment` block
+      // during its single content walk, so `contentBlocks` comes back ready to
+      // ship with no post-processing. The aligned reorder/rewrite keeps the
+      // legacy `attachments` array and `contentOrder` positions consistent.
+      const attachmentRefs = collectAttachmentRefs(m.content);
+      const aligned = alignAttachments(attachmentRefs, msgAttachments);
+      msgAttachments = aligned.attachments;
+      const attachmentBlocks = attachmentRefs.map((_ref, refIdx) => {
+        const att = aligned.refIndexToAttachment.get(refIdx);
+        return att ? toAttachmentBlockRef(att) : null;
+      });
+      const rendered = renderHistoryContent(
+        m.content,
+        attachmentBlocks,
+        m.id ?? undefined,
+      );
 
-    const toolCalls = enrichToolCallsWithQuestion(
-      enrichToolCallsWithConfirmation(rendered.toolCalls, {
-        workspaceDir,
-        pendingConfirmations,
-      }),
-      { pendingQuestions },
-    );
+      const toolCalls = enrichToolCallsWithQuestion(
+        enrichToolCallsWithConfirmation(rendered.toolCalls, {
+          workspaceDir,
+          pendingConfirmations,
+        }),
+        { pendingQuestions },
+      );
 
-    // Strip <no_response/> markers from assistant messages so web/API clients
-    // never see the raw sentinel. Only assistant messages produce it; user
-    // messages are untouched. The filter is applied consistently to the
-    // segments, the contentOrder text refs, and the text blocks of
-    // contentBlocks.
-    let textSegments = rendered.textSegments;
-    let contentOrder = rendered.contentOrder;
-    let contentBlocks = rendered.contentBlocks;
-    if (m.role === "assistant") {
-      const keepIndices: number[] = [];
-      const filteredSegments: string[] = [];
-      for (let i = 0; i < rendered.textSegments.length; i++) {
-        const cleaned = rendered.textSegments[i]
-          .replace(NO_RESPONSE_INLINE_RE, "")
-          .trim();
-        if (cleaned.length > 0) {
-          keepIndices.push(i);
-          filteredSegments.push(cleaned);
+      // Strip <no_response/> markers from assistant messages so web/API clients
+      // never see the raw sentinel. Only assistant messages produce it; user
+      // messages are untouched. The filter is applied consistently to the
+      // segments, the contentOrder text refs, and the text blocks of
+      // contentBlocks.
+      let textSegments = rendered.textSegments;
+      let contentOrder = rendered.contentOrder;
+      let contentBlocks = rendered.contentBlocks;
+      if (m.role === "assistant") {
+        const keepIndices: number[] = [];
+        const filteredSegments: string[] = [];
+        for (let i = 0; i < rendered.textSegments.length; i++) {
+          const cleaned = rendered.textSegments[i]
+            .replace(NO_RESPONSE_INLINE_RE, "")
+            .trim();
+          if (cleaned.length > 0) {
+            keepIndices.push(i);
+            filteredSegments.push(cleaned);
+          }
         }
+        const indexMap = new Map<number, number>();
+        keepIndices.forEach((oldIdx, newIdx) => indexMap.set(oldIdx, newIdx));
+        contentOrder = rendered.contentOrder
+          .map((entry) => {
+            const tm = entry.match(/^text:(\d+)$/);
+            if (!tm) {
+              return entry;
+            }
+            const newIdx = indexMap.get(Number(tm[1]));
+            return newIdx !== undefined ? `text:${newIdx}` : undefined;
+          })
+          .filter((e): e is string => e !== undefined);
+        textSegments = filteredSegments;
+        contentBlocks = rendered.contentBlocks
+          .map((block) =>
+            block.type === "text"
+              ? {
+                  type: "text" as const,
+                  text: block.text.replace(NO_RESPONSE_INLINE_RE, "").trim(),
+                }
+              : block,
+          )
+          .filter((block) => block.type !== "text" || block.text.length > 0);
       }
-      const indexMap = new Map<number, number>();
-      keepIndices.forEach((oldIdx, newIdx) => indexMap.set(oldIdx, newIdx));
-      contentOrder = rendered.contentOrder
-        .map((entry) => {
-          const tm = entry.match(/^text:(\d+)$/);
-          if (!tm) {
-            return entry;
-          }
-          const newIdx = indexMap.get(Number(tm[1]));
-          return newIdx !== undefined ? `text:${newIdx}` : undefined;
-        })
-        .filter((e): e is string => e !== undefined);
-      textSegments = filteredSegments;
-      contentBlocks = rendered.contentBlocks
-        .map((block) =>
-          block.type === "text"
-            ? {
-                type: "text" as const,
-                text: block.text.replace(NO_RESPONSE_INLINE_RE, "").trim(),
-              }
-            : block,
-        )
-        .filter((block) => block.type !== "text" || block.text.length > 0);
-    }
 
-    // Ensure every hydrated attachment has a corresponding content block.
-    // renderHistoryContent inlines attachment blocks only when it has
-    // file-block refs with matching DB rows; directives (assistant-authored
-    // <vellum-attachment/> tags) don't leave a file block after stripping,
-    // so their attachments end up in the flat `attachments` array but not in
-    // `contentBlocks`. Append any that are missing so the canonical
-    // projection is complete.
-    const existingAttachmentIds = new Set(
-      contentBlocks
-        .filter(
-          (b): b is Extract<ConversationContentBlock, { type: "attachment" }> =>
-            b.type === "attachment",
-        )
-        .map((b) => b.attachment.id),
-    );
-    for (const att of msgAttachments) {
-      if (!existingAttachmentIds.has(att.id)) {
-        contentBlocks.push({
-          type: "attachment",
-          attachment: toAttachmentBlockRef(att),
-        });
+      // Ensure every hydrated attachment has a corresponding content block.
+      // renderHistoryContent inlines attachment blocks only when it has
+      // file-block refs with matching DB rows; directives (assistant-authored
+      // <vellum-attachment/> tags) don't leave a file block after stripping,
+      // so their attachments end up in the flat `attachments` array but not in
+      // `contentBlocks`. Append any that are missing so the canonical
+      // projection is complete.
+      const existingAttachmentIds = new Set(
+        contentBlocks
+          .filter(
+            (
+              b,
+            ): b is Extract<ConversationContentBlock, { type: "attachment" }> =>
+              b.type === "attachment",
+          )
+          .map((b) => b.attachment.id),
+      );
+      for (const att of msgAttachments) {
+        if (!existingAttachmentIds.has(att.id)) {
+          contentBlocks.push({
+            type: "attachment",
+            attachment: toAttachmentBlockRef(att),
+          });
+        }
       }
-    }
 
-    const alignedContentOrder = aligned.rewriteContentOrder(contentOrder);
+      const alignedContentOrder = aligned.rewriteContentOrder(contentOrder);
 
-    // Use sentAt (actual event time) for the display timestamp when available,
-    // falling back to createdAt (persistence time). Clients use this display
-    // timestamp as their pagination cursor after memory-pressure trimming,
-    // while server-side pagination filters on createdAt. The mismatch is
-    // benign — it may return slightly extra data on a page boundary but never
-    // loses messages.
-    const displayTimestamp = m.sentAt ?? m.createdAt;
-    return {
-      id: m.id ?? "",
-      ...(mergedMessageIds.length > 0 ? { mergedMessageIds } : {}),
-      ...(m.clientMessageId ? { clientMessageId: m.clientMessageId } : {}),
-      role: m.role,
-      timestamp: new Date(displayTimestamp).toISOString(),
-      attachments: msgAttachments,
-      ...(toolCalls.length > 0 ? { toolCalls } : {}),
-      ...(rendered.surfaces.length > 0 ? { surfaces: rendered.surfaces } : {}),
-      ...(textSegments.length > 0 ? { textSegments } : {}),
-      ...(rendered.thinkingSegments.length > 0
-        ? { thinkingSegments: rendered.thinkingSegments }
-        : {}),
-      ...(alignedContentOrder.length > 0
-        ? { contentOrder: alignedContentOrder }
-        : {}),
-      contentBlocks,
-      ...(m.subagentNotification
-        ? { subagentNotification: m.subagentNotification }
-        : {}),
-      ...(m.acpNotification ? { acpNotification: m.acpNotification } : {}),
-      ...(m.backgroundEventNotification
-        ? { backgroundEventNotification: true }
-        : {}),
-      ...(m.backgroundToolCompletion
-        ? { backgroundToolCompletion: m.backgroundToolCompletion }
-        : {}),
-      ...(m.systemCard ? { systemCard: true } : {}),
-      ...(m.providerError ? { providerError: m.providerError } : {}),
-      ...(m.slackMessage ? { slackMessage: m.slackMessage } : {}),
-    };
-  });
+      // Use sentAt (actual event time) for the display timestamp when available,
+      // falling back to createdAt (persistence time). Clients use this display
+      // timestamp as their pagination cursor after memory-pressure trimming,
+      // while server-side pagination filters on createdAt. The mismatch is
+      // benign: it may return slightly extra data on a page boundary but never
+      // loses messages.
+      const displayTimestamp = m.sentAt ?? m.createdAt;
+      return {
+        id: m.id ?? "",
+        ...(mergedMessageIds.length > 0 ? { mergedMessageIds } : {}),
+        ...(m.clientMessageId ? { clientMessageId: m.clientMessageId } : {}),
+        role: m.role,
+        timestamp: new Date(displayTimestamp).toISOString(),
+        attachments: msgAttachments,
+        ...(toolCalls.length > 0 ? { toolCalls } : {}),
+        ...(rendered.surfaces.length > 0
+          ? { surfaces: rendered.surfaces }
+          : {}),
+        ...(textSegments.length > 0 ? { textSegments } : {}),
+        ...(rendered.thinkingSegments.length > 0
+          ? { thinkingSegments: rendered.thinkingSegments }
+          : {}),
+        ...(alignedContentOrder.length > 0
+          ? { contentOrder: alignedContentOrder }
+          : {}),
+        contentBlocks,
+        ...(m.subagentNotification
+          ? { subagentNotification: m.subagentNotification }
+          : {}),
+        ...(m.acpNotification ? { acpNotification: m.acpNotification } : {}),
+        ...(m.backgroundEventNotification
+          ? { backgroundEventNotification: true }
+          : {}),
+        ...(m.backgroundToolCompletion
+          ? { backgroundToolCompletion: m.backgroundToolCompletion }
+          : {}),
+        ...(m.systemCard ? { systemCard: true } : {}),
+        ...(m.providerError ? { providerError: m.providerError } : {}),
+        ...(m.slackMessage ? { slackMessage: m.slackMessage } : {}),
+      };
+    }),
+  );
 
   // Snapshot↔stream alignment token: the `seq` of the last event whose
   // content is durably persisted for this conversation, read from the
@@ -1579,7 +1621,7 @@ export async function handleSendMessage(
     typeof body.clientTimezone === "string"
       ? (canonicalizeTimeZone(body.clientTimezone) ?? undefined)
       : undefined;
-  // Client OS surface ("web" | "ios" | "macos" | "android"), reported
+  // Client OS surface ("web" | "ios" | "macos" | "windows" | "android"), reported
   // separately from the transport `interface`. Validated against the dedicated
   // `ClientOs` value set (NOT the interface vocabulary) and only kept when it
   // resolves — it drives the per-turn `client_os:` context line, never
@@ -1704,6 +1746,11 @@ export async function handleSendMessage(
     mapping = getOrCreateConversation(resolvedConversationKey, {
       conversationType: "standard",
       title: onboardingTitle,
+      // This route already resolved the channel the message arrived on, and
+      // this is the seam that materializes the row, so the conversation is
+      // attributed from the moment it exists rather than on its first
+      // message.
+      origin: sourceChannel,
     });
   }
 
@@ -1868,6 +1915,15 @@ export async function handleSendMessage(
     conversation.setTrustContext({ trustClass: "guardian", sourceChannel });
   }
 
+  // The trust this request's turn runs under, captured here rather than read
+  // back at the agent loop below. Every branch above has just written it and
+  // nothing awaits in between, so this is the resolved sender. Between here
+  // and the loop the conversation slot is writable by paths that do not own
+  // this turn (channel ingress for another actor, live-voice hydration,
+  // pointer elevation, the voice bridge), and the loop would otherwise
+  // re-read it and run this turn as whoever wrote last.
+  const turnTrustContext = conversation.trustContext;
+
   const isInteractive = isInteractiveInterface(sourceInterface);
   // Translate the dev-bypass actor principal to the real guardian principal
   // before the same-actor host-proxy gate so web/iOS turns match the macOS
@@ -1999,6 +2055,7 @@ export async function handleSendMessage(
         requestId: uuidv7(),
         metadata: greetingMeta,
         clientMessageId,
+        ...(clientOs ? { requestClientOs: clientOs } : {}),
       });
 
       const conversationId = mapping.conversationId;
@@ -2037,34 +2094,37 @@ export async function handleSendMessage(
         }
       }
 
-      setTimeout(() => {
-        broadcastMessage({
-          type: "user_message_echo",
-          text: rawContent,
-          conversationId,
-          messageId: persisted.id,
-          clientMessageId,
-        });
-        broadcastMessage({
-          type: "assistant_text_delta",
-          text: cannedGreeting,
-          conversationId,
-        });
-        emitCannedMessageComplete(
-          broadcastMessage,
-          conversationId,
-          persistedAssistant.id,
-        );
-        // Rows persisted before this deferred burst; advance the
-        // snapshot↔stream anchor past the events just emitted so `/messages`
-        // never returns these rows behind a stale anchor.
-        recordConversationPersistedSeq(conversationId, getCurrentSeq());
-        publishConversationMessagesChanged(conversationId, originClientId);
-        conversation.setProcessing(false);
-        void conversation.kickDrainQueue("loop_complete", "canned_greeting");
-
-        conversation.warmPromptCache();
-      }, 0);
+      scheduleCannedReplyRelease({
+        conversation,
+        origin: "canned_greeting",
+        emit: () => {
+          broadcastMessage({
+            type: "user_message_echo",
+            text: rawContent,
+            conversationId,
+            messageId: persisted.id,
+            clientMessageId,
+          });
+          broadcastMessage({
+            type: "assistant_text_delta",
+            text: cannedGreeting,
+            conversationId,
+          });
+          emitCannedMessageComplete(
+            broadcastMessage,
+            conversationId,
+            persistedAssistant.id,
+          );
+          // Rows persisted before this deferred burst; advance the
+          // snapshot↔stream anchor past the events just emitted so `/messages`
+          // never returns these rows behind a stale anchor.
+          recordConversationPersistedSeq(conversationId, getCurrentSeq());
+          publishConversationMessagesChanged(conversationId, originClientId);
+        },
+        afterRelease: () => {
+          conversation.warmPromptCache();
+        },
+      });
 
       log.info(
         { conversationId, personalized: !!body.onboarding },
@@ -2329,6 +2389,7 @@ export async function handleSendMessage(
         requestId: uuidv7(),
         metadata: withClientMetadata(slashMeta, clientMetadata),
         clientMessageId,
+        ...(clientOs ? { requestClientOs: clientOs } : {}),
       });
       if (persisted.deduplicated) {
         return {
@@ -2372,33 +2433,35 @@ export async function handleSendMessage(
       // starts processing.
       const conversationId = mapping.conversationId;
       const message = slashResult.message;
-      setTimeout(() => {
-        broadcastMessage({
-          type: "user_message_echo",
-          text: rawContent,
-          conversationId,
-          messageId: persisted.id,
-          clientMessageId,
-        });
-        if (modelInfoEvent) {
-          broadcastMessage(modelInfoEvent);
-        }
-        broadcastMessage({
-          type: "assistant_text_delta",
-          text: message,
-          conversationId,
-        });
-        emitCannedMessageComplete(
-          broadcastMessage,
-          conversationId,
-          persistedAssistant.id,
-        );
-        // Same anchor advance as the canned-greeting path above.
-        recordConversationPersistedSeq(conversationId, getCurrentSeq());
-        publishConversationMessagesChanged(conversationId, originClientId);
-        conversation.setProcessing(false);
-        void conversation.kickDrainQueue("loop_complete", "slash_command");
-      }, 0);
+      scheduleCannedReplyRelease({
+        conversation,
+        origin: "slash_command",
+        emit: () => {
+          broadcastMessage({
+            type: "user_message_echo",
+            text: rawContent,
+            conversationId,
+            messageId: persisted.id,
+            clientMessageId,
+          });
+          if (modelInfoEvent) {
+            broadcastMessage(modelInfoEvent);
+          }
+          broadcastMessage({
+            type: "assistant_text_delta",
+            text: message,
+            conversationId,
+          });
+          emitCannedMessageComplete(
+            broadcastMessage,
+            conversationId,
+            persistedAssistant.id,
+          );
+          // Same anchor advance as the canned-greeting path above.
+          recordConversationPersistedSeq(conversationId, getCurrentSeq());
+          publishConversationMessagesChanged(conversationId, originClientId);
+        },
+      });
 
       cleanupDeferred = true;
       return response;
@@ -2428,6 +2491,7 @@ export async function handleSendMessage(
         requestId: uuidv7(),
         metadata: withClientMetadata(slashMeta, clientMetadata),
         clientMessageId,
+        ...(clientOs ? { requestClientOs: clientOs } : {}),
       });
     } catch (err) {
       // The fire-and-forget compaction below owns clearing `processing`, but a
@@ -2522,6 +2586,7 @@ export async function handleSendMessage(
         requestId: uuidv7(),
         metadata: withClientMetadata(slashMeta, clientMetadata),
         clientMessageId,
+        ...(clientOs ? { requestClientOs: clientOs } : {}),
       });
       if (persisted.deduplicated) {
         return {
@@ -2591,6 +2656,7 @@ export async function handleSendMessage(
     ),
     scripted: body.scripted,
     clientMessageId,
+    ...(clientOs ? { requestClientOs: clientOs } : {}),
   });
 
   const messageId = persistResult.id;
@@ -2634,6 +2700,7 @@ export async function handleSendMessage(
       onEvent: broadcastMessage,
       isInteractive,
       isUserMessage: true,
+      turnTrustContext,
       ...(body.hidden === true ? { isHiddenPrompt: true } : {}),
     })
     .catch((err) => {
@@ -3095,7 +3162,7 @@ export const ROUTES: RouteDefinition[] = [
         .string()
         .optional()
         .describe(
-          'Client OS surface ("web" | "ios" | "macos" | "android"), reported separately from `interface`. Drives the per-turn `client_os` context only; does not affect transport/host-proxy capabilities.',
+          'Client OS surface ("web" | "ios" | "macos" | "windows" | "android"), reported separately from `interface`. Drives the per-turn `client_os` context only; does not affect transport/host-proxy capabilities.',
         ),
       visibleAppId: z
         .string()