@vellumai/assistant 0.11.2 → 0.11.3-staging.1

package/src/daemon/conversation-process.ts

@@ -26,6 +26,7 @@ import {
   addMessage,
   isEchoSuppressedUserMessage,
   isHiddenMessageMetadata,
+  isSuppressedQueuedMessage,
   provenanceFromTrustContext,
   recordConversationPersistedSeq,
   setConversationOriginChannelIfUnset,
@@ -285,9 +286,9 @@ async function buildPassthroughBatch(
       break;
     }
     // The batched turn applies only the head's `clientOs`, so messages from a
-    // different OS surface must not coalesce. The web, iOS, and macOS apps all
+    // different OS surface must not coalesce. Browser, mobile, and desktop apps
     // report `interfaceId: "web"`, so the interface check above no longer
-    // separates them — split on the reported OS explicitly.
+    // separates them, so split on the reported OS explicitly.
     if (candidate.transport?.clientOs !== head.transport?.clientOs) {
       break;
     }
@@ -324,10 +325,11 @@ async function buildPassthroughBatch(
   return conversation.queue.shiftN(matched);
 }
 
-// ── Steer repair ────────────────────────────────────────────────────
+// ── Steer / interrupt repair ────────────────────────────────────────
 
 /**
- * When a steer-to-message abort interrupts an in-flight tool call, the
+ * When a steer-to-message abort (or a user interrupt with messages still
+ * queued behind the stopped turn) cuts off an in-flight tool call, the
  * conversation history may end with an assistant message containing one
  * or more `tool_use` blocks that have no corresponding `tool_result`.
  * LLM providers reject this sequence. This helper scans the tail of the
@@ -335,10 +337,12 @@ async function buildPassthroughBatch(
  * unmatched `tool_use` blocks.
  */
 function repairPendingToolUseBlocks(conversation: Conversation): void {
-  if (!conversation.pendingSteerRepair) {
+  const steered = conversation.pendingSteerRepair;
+  if (!steered && !conversation.pendingInterruptRepair) {
     return;
   }
   conversation.pendingSteerRepair = false;
+  conversation.pendingInterruptRepair = false;
 
   const messages = conversation.messages;
   if (messages.length === 0) {
@@ -381,15 +385,18 @@ function repairPendingToolUseBlocks(conversation: Conversation): void {
     {
       conversationId: conversation.conversationId,
       pendingToolUseCount: pendingToolUseIds.length,
+      trigger: steered ? "steer" : "interrupt",
     },
-    "Injecting synthetic tool_result for pending tool_use blocks after steer",
+    "Injecting synthetic tool_result for pending tool_use blocks",
   );
 
   // Build a single user message with tool_result blocks for all pending IDs.
   const syntheticContent = pendingToolUseIds.map((toolUseId) => ({
     type: "tool_result" as const,
     tool_use_id: toolUseId,
-    content: "Tool execution was interrupted by user steering.",
+    content: steered
+      ? "Tool execution was interrupted by user steering."
+      : "Tool execution was interrupted by the user.",
     is_error: true,
   }));
   conversation.messages.push({
@@ -405,11 +412,23 @@ function repairPendingToolUseBlocks(conversation: Conversation): void {
  * we did. The flag is what makes the requeue paths able to distinguish a
  * message clients still believe is running from one they never stopped
  * showing as queued. See {@link requeueDrainedMessages}.
+ *
+ * Queue events come in pairs. A row with no client-visible queued counterpart
+ * ({@link isSuppressedQueuedMessage} — hidden sends and the daemon-injected
+ * subagent/ACP/wake notifications) never produced a `message_queued` ack, so
+ * releasing one produces no dequeue either: an unpaired dequeue would retire a
+ * client's counter entry for a message that is still waiting. Nothing was
+ * announced, so the flag stays false and the requeue paths correctly send
+ * nothing for it. The activity-state transition callers emit alongside this is
+ * unrelated to the queue and always fires: the turn really is starting.
  */
 function announceDequeue(
   conversation: Conversation,
   message: QueuedMessage,
 ): void {
+  if (isSuppressedQueuedMessage(message.metadata)) {
+    return;
+  }
   message.onEvent({
     type: "message_dequeued",
     conversationId: conversation.conversationId,
@@ -434,7 +453,7 @@ function visibleQueuePosition(
 ): number | undefined {
   let position = 0;
   for (const item of conversation.queue.snapshot()) {
-    if (isHiddenMessageMetadata(item.metadata)) {
+    if (isSuppressedQueuedMessage(item.metadata)) {
       continue;
     }
     position += 1;
@@ -460,8 +479,10 @@ function visibleQueuePosition(
  * `message_dequeued` and would otherwise see the row vanish until a later
  * drain. Messages requeued before the announcement (the pre-flight
  * processing-lock checks) get nothing, because clients never stopped showing
- * them as queued and an event there would be noise. Hidden sends are suppressed
- * for the same reason they get no queued ack: they have no client row.
+ * them as queued and an event there would be noise. Rows with no client-visible
+ * queued counterpart ({@link isSuppressedQueuedMessage} — hidden sends and
+ * daemon-injected subagent/ACP/wake notifications) are suppressed for the same
+ * reason they get no queued ack: they have no client row.
  */
 function requeueDrainedMessages(
   conversation: Conversation,
@@ -488,7 +509,7 @@ function requeueDrainedMessages(
       continue;
     }
     message.dequeueAnnounced = false;
-    if (isHiddenMessageMetadata(message.metadata)) {
+    if (isSuppressedQueuedMessage(message.metadata)) {
       continue;
     }
     const position = visibleQueuePosition(conversation, message.requestId);
@@ -653,7 +674,15 @@ export async function kickQueueDrain(
       },
       "drainQueue retry rejected; queued messages remain stranded until the next drain trigger",
     );
-    for (const queued of conversation.queue.snapshot()) {
+    // Only the sends a user is waiting on get the failure notice. A stranded
+    // row with no client-visible queued counterpart (hidden machine signal,
+    // daemon-injected subagent/ACP/wake notification) has no queued bubble to
+    // explain, so a "your queued message" error would describe something the
+    // user never sent.
+    const strandedVisible = conversation.queue
+      .snapshot()
+      .filter((queued) => !isSuppressedQueuedMessage(queued.metadata));
+    for (const queued of strandedVisible) {
       queued.onEvent({
         type: "error",
         conversationId: conversation.conversationId,
@@ -813,7 +842,10 @@ async function drainSingleMessage(
           : {}),
         sentAt: next.sentAt,
       };
-      const cleanUserMsg = createUserMessage(next.content, next.attachments);
+      const cleanUserMsg = await createUserMessage(
+        next.content,
+        next.attachments,
+      );
       const llmUserMsg = enrichMessageWithSourcePaths(
         cleanUserMsg,
         next.attachments,
@@ -821,7 +853,7 @@ async function drainSingleMessage(
       // When displayContent is provided (e.g. original text before recording
       // intent stripping), persist that to DB so users see the full message.
       // The in-memory userMessage (sent to the LLM) still uses the stripped content.
-      const contentToPersist = serializePersistedUserMessageContent(
+      const contentToPersist = await serializePersistedUserMessageContent(
         next.content,
         next.displayContent,
         next.attachments,
@@ -913,11 +945,14 @@ async function drainSingleMessage(
           : {}),
         sentAt: next.sentAt,
       };
-      const cleanUserMsg = createUserMessage(next.content, next.attachments);
+      const cleanUserMsg = await createUserMessage(
+        next.content,
+        next.attachments,
+      );
       await addMessage(
         conversation.conversationId,
         "user",
-        serializePersistedUserMessageContent(
+        await serializePersistedUserMessageContent(
           next.content,
           next.displayContent,
           next.attachments,
@@ -1003,11 +1038,14 @@ async function drainSingleMessage(
           : {}),
         sentAt: next.sentAt,
       };
-      const cleanUserMsg = createUserMessage(next.content, next.attachments);
+      const cleanUserMsg = await createUserMessage(
+        next.content,
+        next.attachments,
+      );
       await addMessage(
         conversation.conversationId,
         "user",
-        serializePersistedUserMessageContent(
+        await serializePersistedUserMessageContent(
           next.content,
           next.displayContent,
           next.attachments,
@@ -1097,6 +1135,9 @@ async function drainSingleMessage(
       metadata: { ...next.metadata, sentAt: next.sentAt },
       displayContent: next.displayContent,
       clientMessageId: next.clientMessageId,
+      ...(next.transport?.clientOs
+        ? { requestClientOs: next.transport.clientOs }
+        : {}),
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1447,6 +1488,9 @@ async function drainBatch(
         metadata: { ...qm.metadata, sentAt: qm.sentAt },
         displayContent: qm.displayContent,
         clientMessageId: qm.clientMessageId,
+        ...(qm.transport?.clientOs
+          ? { requestClientOs: qm.transport.clientOs }
+          : {}),
       };
       if (i === 0) {
         batchPersistResult =
@@ -1873,7 +1917,7 @@ export async function processMessage(
           : {}),
       };
 
-      const cleanUserMsg = createUserMessage(content, attachments);
+      const cleanUserMsg = await createUserMessage(content, attachments);
       const llmUserMsg = enrichMessageWithSourcePaths(
         cleanUserMsg,
         attachments,
@@ -1881,7 +1925,7 @@ export async function processMessage(
       const persisted = await addMessage(
         conversation.conversationId,
         "user",
-        serializePersistedUserMessageContent(
+        await serializePersistedUserMessageContent(
           content,
           displayContent,
           attachments,
@@ -1965,12 +2009,12 @@ export async function processMessage(
         ? { imageSourcePaths: pmImageSourcePaths }
         : {}),
     };
-    const cleanUserMsg = createUserMessage(content, attachments);
+    const cleanUserMsg = await createUserMessage(content, attachments);
     const llmUserMsg = enrichMessageWithSourcePaths(cleanUserMsg, attachments);
     // When displayContent is provided (e.g. original text before recording
     // intent stripping), persist that to DB so users see the full message.
     // The in-memory userMessage (sent to the LLM) still uses the stripped content.
-    const contentToPersist = serializePersistedUserMessageContent(
+    const contentToPersist = await serializePersistedUserMessageContent(
       content,
       displayContent,
       attachments,
@@ -2049,11 +2093,11 @@ export async function processMessage(
             }
           : {}),
       };
-      const cleanUserMsg = createUserMessage(content, attachments);
+      const cleanUserMsg = await createUserMessage(content, attachments);
       const persisted = await addMessage(
         conversation.conversationId,
         "user",
-        serializePersistedUserMessageContent(
+        await serializePersistedUserMessageContent(
           content,
           displayContent,
           attachments,
@@ -2097,7 +2141,10 @@ export async function processMessage(
       throw err;
     } finally {
       conversation.setProcessing(false);
-      await drainQueue(conversation);
+      // `kickQueueDrain` never rejects, so a failed drain in this `finally`
+      // cannot mask the error the try block is unwinding, and its retry plus
+      // sender notification replace a silently stranded queue.
+      await kickQueueDrain(conversation, "loop_complete", "compact_command");
     }
   }
 
@@ -2127,11 +2174,11 @@ export async function processMessage(
             }
           : {}),
       };
-      const cleanUserMsg = createUserMessage(content, attachments);
+      const cleanUserMsg = await createUserMessage(content, attachments);
       const persisted = await addMessage(
         conversation.conversationId,
         "user",
-        serializePersistedUserMessageContent(
+        await serializePersistedUserMessageContent(
           content,
           displayContent,
           attachments,
@@ -2171,7 +2218,8 @@ export async function processMessage(
       throw err;
     } finally {
       conversation.setProcessing(false);
-      await drainQueue(conversation);
+      // Same never-rejecting drain as the `/compact` branch above.
+      await kickQueueDrain(conversation, "loop_complete", "clean_command");
     }
   }
 

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

@@ -451,12 +451,18 @@ export function buildActiveDocuments(conversationId: string): Array<{
  * 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.
+ *
+ * The resolved directory is not part of the returned shape. A workspace app's
+ * files are reachable by joining the workspace `Root:` from the `<workspace>`
+ * block with the app-builder skill's `data/apps/<slug>/` layout and the slug
+ * above. A plugin-bundled app's files sit outside that layout and belong to
+ * the plugin, which the provenance clause marks as not the assistant's to
+ * rewrite, so no path is offered for them either.
  */
 export function buildVisibleAppContext(appId: string | undefined): {
   appId: string;
   name: string;
   slug: string;
-  sourceDir: string;
   pluginName?: string;
 } | null {
   if (!appId) {
@@ -471,7 +477,6 @@ export function buildVisibleAppContext(appId: string | undefined): {
       appId: source.id,
       name: source.name,
       slug: source.dirName,
-      sourceDir: source.sourceDir,
       ...(source.origin.kind === "plugin"
         ? { pluginName: source.origin.pluginName }
         : {}),
@@ -2239,10 +2244,10 @@ export async function applyRuntimeInjections(
     : undefined;
   // OS surface reported by the client, independent of the transport interface
   // above. Drives the per-turn `client_os:` line so the model knows whether it
-  // is talking to the web, iOS, or macOS app (all sharing the `"web"`
+  // is talking to a browser, mobile, or desktop app (all sharing the `"web"`
   // transport interface). Read the frozen per-turn snapshot (not the live
   // `clientOs`) so a queued message from another surface can't perturb the
-  // in-flight turn — same anti-race pattern as `clientTimezone`.
+  // in-flight turn, using the 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

package/src/daemon/conversation-store.ts

@@ -19,6 +19,7 @@ import {
   ensureConversationExists,
   getConversation,
 } from "../persistence/conversation-crud.js";
+import type { ConversationOrigin } from "../persistence/conversation-types.js";
 import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
 import {
   mainAgentResolutionError,
@@ -51,6 +52,37 @@ import { buildTransportHints } from "./transport-hints.js";
 
 const conversationOptions = new Map<string, ConversationCreateOptions>();
 
+/**
+ * The channel a conversation created here belongs to.
+ *
+ * A trust context is stamped per inbound message from the gateway verdict,
+ * so `sourceChannel` names the channel the message creating this
+ * conversation actually arrived on. This is the moment that fact is known,
+ * and the caller is the only party that holds it.
+ *
+ * Returns `undefined` when there is no trust context, which does NOT mean
+ * native. `handleSendMessage` materializes a conversation before the route
+ * resolves trust, so a Slack or phone send reaches here with no
+ * `sourceChannel` yet. Assuming native there would stamp a remote
+ * conversation as the guardian's own, and nothing could repair it:
+ * `setConversationOriginChannelIfUnset` only writes over NULL, and
+ * `recoverRestingTrustContext` grants INTERNAL_GUARDIAN_TRUST_CONTEXT to the
+ * native channel on every later wake and boot-resume.
+ *
+ * `transport.channelId` is not a substitute. It is the external Slack
+ * conversation id, not a {@link ChannelId}.
+ *
+ * So this states the origin only where it is genuinely known, and leaves the
+ * rest to attribution exactly as before. The remaining callers get their
+ * origin when they are migrated with real knowledge of it, not by guessing
+ * here.
+ */
+function originFromStoredOptions(
+  storedOptions: ConversationCreateOptions | undefined,
+): ConversationOrigin | undefined {
+  return storedOptions?.trustContext?.sourceChannel;
+}
+
 /**
  * Drops the transport fields that describe what the client had on screen for a
  * single message rather than for the conversation as a whole.
@@ -141,9 +173,17 @@ export async function getOrCreateConversation(
     );
   }
 
+  // A stale conversation is rebuilt only once it is genuinely idle. Queued
+  // messages live in memory on the instance being disposed, and the queue
+  // drains via an async dispatch after the current turn releases, so
+  // `isProcessing()` can read false while a queued turn is still pending:
+  // rebuilding in that gap would silently drop those messages. The conversation
+  // stays stale and is rebuilt on a later call.
   if (
     !conversation ||
-    (conversation.isStale() && !conversation.isProcessing())
+    (conversation.isStale() &&
+      !conversation.isProcessing() &&
+      !conversation.hasQueuedMessages())
   ) {
     if (conversation) {
       // Stale rebuild: the conversation id lives on, so abort in-flight
@@ -229,9 +269,13 @@ export async function getOrCreateConversation(
           createConversation({
             id: conversationId,
             conversationType: storedOptions.conversationType,
+            origin: originFromStoredOptions(storedOptions),
           });
         } else {
-          ensureConversationExists(conversationId);
+          ensureConversationExists(
+            conversationId,
+            originFromStoredOptions(storedOptions),
+          );
         }
       }
 
@@ -353,7 +397,12 @@ export function clearAllActiveConversations(): number {
 export function evictConversationsForReload(): void {
   const subagentManager = getSubagentManager();
   for (const [id, conversation] of conversationEntries()) {
-    if (!conversation.isProcessing()) {
+    // A conversation with queued messages is not idle: the queue drains via an
+    // async dispatch after the current turn releases, so `isProcessing()` can
+    // read false while a queued turn is still pending. Disposing in that gap
+    // would silently drop the queued messages, so mark it stale instead and
+    // let it rebuild once the queue has run.
+    if (!conversation.isProcessing() && !conversation.hasQueuedMessages()) {
       subagentManager.abortAllForParent(id);
       conversation.dispose();
       deleteConversation(id);

package/src/daemon/conversation-surface-state.ts

@@ -76,6 +76,15 @@ export type CurrentTurnSurface = {
      * to the client.
      */
     activationMoment?: ActivationMomentParam;
+    /**
+     * Completion stamped when the user answers the surface before this turn's
+     * message lands. The snapshot is the only record of the surface at that
+     * point, so both persisted-content appenders carry these onto the
+     * `ui_surface` block they build; without them a reseed reactivates an
+     * already-answered card.
+     */
+    completed?: boolean;
+    completionSummary?: string;
   };
 }[SurfaceType];