@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/daemon/conversation-process.ts

@@ -60,6 +60,21 @@ import { resolveVerificationSessionIntent } from "./verification-session-intent.
 
 const log = getLogger("conversation-process");
 
+/**
+ * Daemon-injected subagent lifecycle notifications carry `subagentNotification`
+ * metadata. They are persisted into the parent conversation so the orchestrator
+ * wakes and reads the subagent's result, but they are internal scaffolding — the
+ * user sees subagent activity through the inline progress card, not a chat turn.
+ * Skip the `user_message_echo` broadcast for these so they never render as a live
+ * user bubble; the persisted row is filtered from the rendered transcript on the
+ * client.
+ */
+function isSubagentNotificationMessage(
+  metadata: Record<string, unknown> | undefined,
+): boolean {
+  return metadata?.subagentNotification != null;
+}
+
 /** Format the result of a forced compaction into a user-facing message. */
 export function formatCompactResult(result: ContextWindowResult): string {
   const fmt = (n: number | undefined) => (n ?? 0).toLocaleString("en-US");
@@ -853,14 +868,16 @@ async function drainSingleMessage(
 
   // Broadcast the user message to all hub subscribers so passive devices
   // see the user turn before the assistant reply starts streaming.
-  next.onEvent({
-    type: "user_message_echo",
-    text: resolvedContent,
-    conversationId: conversation.conversationId,
-    messageId: userMessageId,
-    requestId: next.requestId,
-    clientMessageId: next.clientMessageId,
-  });
+  if (!isSubagentNotificationMessage(next.metadata)) {
+    next.onEvent({
+      type: "user_message_echo",
+      text: resolvedContent,
+      conversationId: conversation.conversationId,
+      messageId: userMessageId,
+      requestId: next.requestId,
+      clientMessageId: next.clientMessageId,
+    });
+  }
   publishConversationMessagesChanged(conversation.conversationId);
 
   // Set the active surface for the dequeued message so runAgentLoop can inject context
@@ -1204,14 +1221,16 @@ async function drainBatch(
 
     // Broadcast the user message to all hub subscribers so passive devices
     // see each batched user turn before the assistant reply starts streaming.
-    qm.onEvent({
-      type: "user_message_echo",
-      text: qmContent,
-      conversationId: conversation.conversationId,
-      messageId: lastUserMessageId,
-      requestId: qm.requestId,
-      clientMessageId: qm.clientMessageId,
-    });
+    if (!isSubagentNotificationMessage(qm.metadata)) {
+      qm.onEvent({
+        type: "user_message_echo",
+        text: qmContent,
+        conversationId: conversation.conversationId,
+        messageId: lastUserMessageId,
+        requestId: qm.requestId,
+        clientMessageId: qm.clientMessageId,
+      });
+    }
     publishConversationMessagesChanged(conversation.conversationId);
 
     // Persist succeeded. Update last-successful markers so a later tail

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

@@ -13,6 +13,7 @@ import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { isMemoryV3Live } from "../config/memory-v3-gate.js";
 import type { LLMCallSite, LLMConfig } from "../config/schemas/llm.js";
+import { findContactInfoById } from "../contacts/contact-store.js";
 import {
   NOW_SCRATCHPAD_STRIP_PREFIXES,
   stripSpotlightInjections,
@@ -60,14 +61,8 @@ import type {
   TurnContext,
 } from "../plugins/types.js";
 import type { ContentBlock, Message } from "../providers/types.js";
-import {
-  type ActorTrustContext,
-  resolveActorTrust,
-  type TrustClass,
-} from "../runtime/actor-trust-resolver.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { resolveCapabilities } from "../runtime/capabilities.js";
-import { channelStatusToMemberStatus } from "../runtime/routes/inbound-stages/acl-enforcement.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { SubagentState } from "../subagent/types.js";
 import { TERMINAL_STATUSES } from "../subagent/types.js";
@@ -156,32 +151,8 @@ export function inboundActorContextFromTrustContext(
     actorMemberDisplayName: ctx.requesterMemberDisplayName,
     trustClass: ctx.trustClass,
     guardianIdentity: ctx.guardianExternalUserId,
-  };
-}
-
-/**
- * Construct an InboundActorContext from an ActorTrustContext (the new
- * unified trust resolver output from M1).
- */
-export function inboundActorContextFromTrust(
-  ctx: ActorTrustContext,
-): InboundActorContext {
-  return {
-    sourceChannel: ctx.actorMetadata.channel,
-    canonicalActorIdentity: ctx.canonicalSenderId,
-    actorIdentifier: ctx.actorMetadata.identifier,
-    actorDisplayName: ctx.actorMetadata.displayName,
-    actorSenderDisplayName: ctx.actorMetadata.senderDisplayName,
-    actorMemberDisplayName: ctx.actorMetadata.memberDisplayName,
-    trustClass: ctx.trustClass,
-    guardianIdentity: ctx.guardianBindingMatch?.guardianExternalUserId,
-    memberStatus: ctx.memberRecord
-      ? channelStatusToMemberStatus(ctx.memberRecord.channel.status)
-      : undefined,
-    memberPolicy: ctx.memberRecord?.channel.policy ?? undefined,
-    contactNotes: ctx.memberRecord?.contact.notes ?? undefined,
-    contactInteractionCount:
-      ctx.memberRecord?.contact.interactionCount ?? undefined,
+    memberStatus: ctx.memberStatus,
+    memberPolicy: ctx.memberPolicy,
   };
 }
 
@@ -190,33 +161,30 @@ export function inboundActorContextFromTrust(
  * conversation's trust context, for the unified `<turn_context>` actor section.
  *
  * Returns `null` when there is no trust context and on guardian (owner) turns —
- * the actor section is suppressed for the owner. When the trust context carries
- * enough identity to look up member status / policy and the guardian binding,
- * the unified actor-trust resolver is preferred; otherwise the context is
- * projected directly. Derives purely from the passed trust context, so callers
+ * the actor section is suppressed for the owner. ACL fields (trust class,
+ * member status/policy, guardian binding) come from the verdict-derived trust
+ * context; INFO fields (contact notes, interaction count) are joined locally by
+ * contact ID. Derives purely from the passed trust context, so callers
  * self-resolve it from the live conversation rather than threading it.
  */
 export function resolveTurnInboundActorContext(
   trustContext: TrustContext | undefined,
-  assistantId: string | undefined,
 ): InboundActorContext | null {
   if (!trustContext) {
     return null;
   }
-  let resolved: InboundActorContext;
-  if (trustContext.requesterExternalUserId && trustContext.requesterChatId) {
-    const actorTrust = resolveActorTrust({
-      assistantId: assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
-      sourceChannel: trustContext.sourceChannel,
-      conversationExternalId: trustContext.requesterChatId,
-      actorExternalId: trustContext.requesterExternalUserId,
-      actorDisplayName: trustContext.requesterSenderDisplayName,
-    });
-    resolved = inboundActorContextFromTrust(actorTrust);
-  } else {
-    resolved = inboundActorContextFromTrustContext(trustContext);
+  const resolved = inboundActorContextFromTrustContext(trustContext);
+  if (resolved.trustClass === "guardian") {
+    return null;
   }
-  return resolved.trustClass === "guardian" ? null : resolved;
+  if (trustContext.requesterContactId) {
+    const info = findContactInfoById(trustContext.requesterContactId);
+    if (info) {
+      resolved.contactNotes = info.notes ?? undefined;
+      resolved.contactInteractionCount = info.interactionCount;
+    }
+  }
+  return resolved;
 }
 
 /**
@@ -681,13 +649,14 @@ export function stripNowScratchpad(messages: Message[]): Message[] {
 }
 
 /**
- * Prepend channel capability context to the last user message so the
- * model knows what the current channel can and cannot do.
+ * Build the `<channel_capabilities>` block text for the given capabilities, or
+ * `null` on the happy path (desktop, full capabilities, no special context)
+ * where no block is injected. Split from {@link injectChannelCapabilityContext}
+ * so callers can capture the exact injected text for metadata persistence.
  */
-export function injectChannelCapabilityContext(
-  message: Message,
+export function buildChannelCapabilityBlock(
   caps: ChannelCapabilities,
-): Message {
+): string | null {
   // Happy path: desktop with full capabilities and no special context — skip injection.
   if (
     caps.dashboardCapable &&
@@ -696,7 +665,7 @@ export function injectChannelCapabilityContext(
     !isGroupChatType(caps.chatType) &&
     caps.clientOS !== "macos"
   ) {
-    return message;
+    return null;
   }
 
   const lines: string[] = ["<channel_capabilities>"];
@@ -769,7 +738,16 @@ export function injectChannelCapabilityContext(
 
   lines.push("</channel_capabilities>");
 
-  const block = lines.join("\n");
+  return lines.join("\n");
+}
+
+/** Prepend the `<channel_capabilities>` block (if any) to a user message. */
+export function injectChannelCapabilityContext(
+  message: Message,
+  caps: ChannelCapabilities,
+): Message {
+  const block = buildChannelCapabilityBlock(caps);
+  if (block === null) return message;
   return {
     ...message,
     content: [{ type: "text", text: block }, ...message.content],
@@ -1512,6 +1490,14 @@ export function loadSlackActiveThreadFocusBlock(
  */
 export type InjectionMode = "full" | "minimal";
 
+/**
+ * The `<non_interactive_context>` block appended on non-interactive turns.
+ * Module-scoped so `applyRuntimeInjections` both injects it and captures the
+ * exact text for metadata persistence from a single source of truth.
+ */
+export const NON_INTERACTIVE_CONTEXT_BLOCK =
+  "<non_interactive_context>\nNon-interactive scheduled task — do not ask for clarification or confirmation. Follow the instructions exactly using your best judgment. If recalled memory contains conflicting notes, prefer the explicit instruction in this message.\n</non_interactive_context>";
+
 /**
  * Per-turn injection bytes captured so `loadFromDb` can rehydrate historical
  * user messages byte-for-byte after a daemon restart or conversation
@@ -1527,6 +1513,27 @@ export interface RuntimeInjectionBlocks {
   nowScratchpadBlock?: string;
   pkbContextBlock?: string;
   memoryV2StaticBlock?: string;
+  /**
+   * The `<background_turn>` block the `background-turn` default injector
+   * attached this turn (background/scheduled non-interactive turns only).
+   * Persisted under `metadata.backgroundTurnBlock` so `loadFromDb` rehydrates
+   * it byte-for-byte on reload/fork — without it, a fork of a background
+   * source (memory retrospective) drops the block and breaks message-tier
+   * prefix-cache parity with the source's live turns.
+   */
+  backgroundTurnBlock?: string;
+  /**
+   * The `<channel_capabilities>` block injected this turn (non-default channel
+   * capabilities). Persisted under `metadata.channelCapabilitiesBlock` for the
+   * same reload/fork cache-parity reason as {@link backgroundTurnBlock}.
+   */
+  channelCapabilitiesBlock?: string;
+  /**
+   * The `<non_interactive_context>` block injected this turn (non-interactive
+   * turns only). Persisted under `metadata.nonInteractiveContextBlock` for the
+   * same reload/fork cache-parity reason as {@link backgroundTurnBlock}.
+   */
+  nonInteractiveContextBlock?: string;
   /**
    * UNWRAPPED inner text of the memory-v3 frozen net-new card block the v3
    * injector attached this turn, mirroring v2's unwrapped `memoryInjectedBlock`
@@ -2108,6 +2115,9 @@ export async function applyRuntimeInjections(
   let pkbSystemReminderCaptured: string | undefined;
   let memoryV2StaticCaptured: string | undefined;
   let memoryV3Captured: string | undefined;
+  let backgroundTurnCaptured: string | undefined;
+  let channelCapabilitiesCaptured: string | undefined;
+  let nonInteractiveContextCaptured: string | undefined;
   const initialTail = runMessages[runMessages.length - 1];
   const initialTailIsUser = !!initialTail && initialTail.role === "user";
   if (initialTailIsUser) {
@@ -2131,6 +2141,9 @@ export async function applyRuntimeInjections(
         case "memory-v2-static":
           memoryV2StaticCaptured = block.text;
           break;
+        case "background-turn":
+          backgroundTurnCaptured = block.text;
+          break;
         case MEMORY_V3_BLOCK_ID: {
           // The v3 frozen card block is persisted UNWRAPPED (the v2
           // `memoryInjectedBlock` contract — rehydration re-wraps on use).
@@ -2260,16 +2273,14 @@ export async function applyRuntimeInjections(
   if (isNonInteractive) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
+      nonInteractiveContextCaptured = NON_INTERACTIVE_CONTEXT_BLOCK;
       result = [
         ...result.slice(0, -1),
         {
           ...userTail,
           content: [
             ...userTail.content,
-            {
-              type: "text" as const,
-              text: "<non_interactive_context>\nNon-interactive scheduled task — do not ask for clarification or confirmation. Follow the instructions exactly using your best judgment. If recalled memory contains conflicting notes, prefer the explicit instruction in this message.\n</non_interactive_context>",
-            },
+            { type: "text" as const, text: NON_INTERACTIVE_CONTEXT_BLOCK },
           ],
         },
       ];
@@ -2310,10 +2321,21 @@ export async function applyRuntimeInjections(
   if (channelCapabilities) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        injectChannelCapabilityContext(userTail, channelCapabilities),
-      ];
+      const channelCapabilityBlock =
+        buildChannelCapabilityBlock(channelCapabilities);
+      if (channelCapabilityBlock !== null) {
+        channelCapabilitiesCaptured = channelCapabilityBlock;
+        result = [
+          ...result.slice(0, -1),
+          {
+            ...userTail,
+            content: [
+              { type: "text" as const, text: channelCapabilityBlock },
+              ...userTail.content,
+            ],
+          },
+        ];
+      }
     }
   }
 
@@ -2372,6 +2394,9 @@ export async function applyRuntimeInjections(
       pkbContextBlock: pkbContextCaptured,
       memoryV2StaticBlock: memoryV2StaticCaptured,
       memoryV3InjectedBlock: memoryV3Captured,
+      backgroundTurnBlock: backgroundTurnCaptured,
+      channelCapabilitiesBlock: channelCapabilitiesCaptured,
+      nonInteractiveContextBlock: nonInteractiveContextCaptured,
       memoryV3Active,
       injectorChainBlock,
     },