@vellumai/assistant 0.8.2 → 0.8.4

package/src/daemon/handlers/shared.ts

@@ -92,6 +92,19 @@ export interface HistorySurface {
   completionSummary?: string;
 }
 
+/**
+ * Positional reference to a file attachment captured while walking the
+ * content array. The index of an entry in `RenderedHistoryContent.attachments`
+ * is what `contentOrder` references as `attachment:N`.
+ */
+export interface HistoryAttachmentRef {
+  /** Stable DB attachment id when persisted on the file block (`_attachmentId`). */
+  attachmentId?: string;
+  filename: string;
+  mimeType: string;
+  sizeBytes: number;
+}
+
 export interface RenderedHistoryContent {
   text: string;
   toolCalls: HistoryToolCall[];
@@ -99,12 +112,18 @@ export interface RenderedHistoryContent {
   toolCallsBeforeText: boolean;
   /** Text segments split by tool-call boundaries. */
   textSegments: string[];
-  /** Content block ordering using "text:N", "tool:N", "surface:N" encoding. */
+  /** Content block ordering using "text:N", "tool:N", "surface:N", "attachment:N" encoding. */
   contentOrder: string[];
   /** UI surfaces (widgets) embedded in the message. */
   surfaces: HistorySurface[];
   /** Thinking segments extracted from thinking blocks. */
   thinkingSegments: string[];
+  /**
+   * File attachments captured in content order. Index `N` matches an
+   * `attachment:N` entry in `contentOrder`. Callers align their DB-sourced
+   * attachment metadata to this ordering for inline placement.
+   */
+  attachments: HistoryAttachmentRef[];
 }
 
 /**
@@ -115,6 +134,8 @@ export interface RenderedHistoryContent {
 export interface SlackInboundMessageMetadata {
   /** Slack channel id (conversation external id) — recorded as `channelId`. */
   channelId: string;
+  /** Human-readable Slack channel name, when the gateway supplied it. */
+  channelName?: string;
   /** Slack `ts` for this message — required so persistence can record `channelTs`. */
   channelTs: string;
   /** Parent `thread_ts` when the message lives inside a thread; absent for top-level. */
@@ -123,6 +144,18 @@ export interface SlackInboundMessageMetadata {
   displayName?: string;
   /** Canonical Slack external user id for the sender, when available. */
   actorExternalUserId?: string;
+  /** Raw Slack profile timezone for the sender, when supplied. */
+  actorTimezone?: string;
+  /** Compact Slack profile timezone label for the sender, when supplied. */
+  actorTimezoneLabel?: string;
+  /** Raw Slack profile timezone offset in seconds, when supplied. */
+  actorTimezoneOffsetSeconds?: number;
+  /** Timezone used to render this message's timestamp. */
+  timestampTimezone?: string;
+  /** Compact label for the rendered timestamp timezone. */
+  timestampTimezoneLabel?: string;
+  /** Compact timezone label appended to the rendered speaker name. */
+  speakerTimezoneLabel?: string;
 }
 
 /**
@@ -144,8 +177,6 @@ export interface ConversationCreateOptions {
   authContext?: AuthContext;
   /** Whether this turn can block on interactive approval prompts. */
   isInteractive?: boolean;
-  /** Slack-only non-persisted notice injected into the active model turn. */
-  slackRuntimeContextNotice?: string;
   /**
    * Persisted user-facing content. When present, storage/UI use this value
    * while the model-facing turn continues to use `content`.
@@ -192,22 +223,42 @@ function clampAttachmentText(text: string): string {
   return `${text.slice(0, HISTORY_ATTACHMENT_TEXT_LIMIT)}<truncated />`;
 }
 
-function renderFileBlockForHistory(block: Record<string, unknown>): string {
+interface FileBlockMetadata {
+  mediaType: string;
+  filename: string;
+  sizeBytes: number;
+}
+
+function extractFileBlockMetadata(
+  block: Record<string, unknown>,
+): FileBlockMetadata {
   const source = isRecord(block.source) ? block.source : null;
-  const mediaType =
-    source && typeof source.media_type === "string"
-      ? source.media_type
-      : "application/octet-stream";
-  const filename =
-    source && typeof source.filename === "string"
-      ? source.filename
-      : "attachment";
-  const sizeBytes =
-    source && typeof source.data === "string"
-      ? estimateBase64Bytes(source.data)
-      : 0;
-  const summaryParts = [`[File attachment] ${filename}`, `type=${mediaType}`];
-  if (sizeBytes > 0) summaryParts.push(`size=${formatBytes(sizeBytes)}`);
+  return {
+    mediaType:
+      source && typeof source.media_type === "string"
+        ? source.media_type
+        : "application/octet-stream",
+    filename:
+      source && typeof source.filename === "string"
+        ? source.filename
+        : "attachment",
+    sizeBytes:
+      source && typeof source.data === "string"
+        ? estimateBase64Bytes(source.data)
+        : 0,
+  };
+}
+
+function renderFileBlockForHistory(
+  block: Record<string, unknown>,
+  meta: FileBlockMetadata,
+): string {
+  const summaryParts = [
+    `[File attachment] ${meta.filename}`,
+    `type=${meta.mediaType}`,
+  ];
+  if (meta.sizeBytes > 0)
+    summaryParts.push(`size=${formatBytes(meta.sizeBytes)}`);
 
   const extractedText =
     typeof block.extracted_text === "string" ? block.extracted_text.trim() : "";
@@ -237,11 +288,13 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
       contentOrder: text ? ["text:0"] : [],
       surfaces: [],
       thinkingSegments: [],
+      attachments: [],
     };
   }
 
   const textParts: string[] = [];
   const attachmentParts: string[] = [];
+  const attachments: HistoryAttachmentRef[] = [];
   const toolCalls: HistoryToolCall[] = [];
   const surfaces: HistorySurface[] = [];
   const thinkingSegments: string[] = [];
@@ -351,7 +404,19 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
       continue;
     }
     if (block.type === "file") {
-      attachmentParts.push(renderFileBlockForHistory(block));
+      const meta = extractFileBlockMetadata(block);
+      attachmentParts.push(renderFileBlockForHistory(block, meta));
+      finalizeSegment();
+      const ref: HistoryAttachmentRef = {
+        filename: meta.filename,
+        mimeType: meta.mediaType,
+        sizeBytes: meta.sizeBytes,
+      };
+      if (typeof block._attachmentId === "string" && block._attachmentId) {
+        ref.attachmentId = block._attachmentId;
+      }
+      attachments.push(ref);
+      contentOrder.push(`attachment:${attachments.length - 1}`);
       continue;
     }
     if (block.type === "image") {
@@ -495,17 +560,14 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
           matched.imageData = imageDataList[0];
           matched.imageDataList = imageDataList;
         }
-      } else {
-        toolCalls.push({
-          name: "unknown",
-          input: {},
-          result: resultContent,
-          isError,
-          ...(imageDataList.length > 0
-            ? { imageData: imageDataList[0], imageDataList }
-            : {}),
-        });
       }
+      // Orphan tool_result with no matching tool_use — drop it. Synthesizing
+      // a "name: 'unknown'" phantom entry rendered in chat as "Used unknown"
+      // / "Completed 1 step" with no context, with a timestamp later than
+      // the assistant's final answer. Most commonly orphans appear when
+      // context-window compaction trims the parent tool_use block while
+      // leaving the paired tool_result. Losing the orphan's result content
+      // is correct: without the parent we can't tell the user what tool ran.
       continue;
     }
   }
@@ -541,6 +603,7 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
     contentOrder,
     surfaces,
     thinkingSegments,
+    attachments,
   };
 }
 

package/src/daemon/host-app-control-proxy.ts

@@ -22,10 +22,11 @@
  * `running`; the rollback path on a failed `start` restores from the
  * current confirmed pointer (not from a per-call snapshot of a sibling
  * optimistic write), so two overlapping starts that both fail cannot
- * leave a phantom lock — and a late-arriving `running` for an older
- * overlapping start still updates the confirmed pointer so the lock
- * survives a subsequent rollback of the newer start. The lock is
- * released outright when the owning proxy's `dispose()` fires.
+ * leave a phantom lock. Each session carries a monotonic `dispatchedAt`
+ * counter so out-of-order `running` responses promote in dispatch order:
+ * the latest-dispatched start that the host confirms becomes the
+ * confirmed baseline, regardless of which response arrived last. The
+ * lock is released outright when the owning proxy's `dispose()` fires.
  *
  * `app_control_start` is the only tool that can acquire the lock — the
  * user's medium-risk approval at start time is the consent boundary. All
@@ -84,8 +85,22 @@ export interface ActiveAppControlSession {
    * the `app` of subsequent non-start tool calls.
    */
   app: string;
+  /**
+   * Strictly monotonic counter assigned when the session is created (in
+   * `request()` for a `start`). Used by {@link promoteStartIfCurrent} to
+   * tell which of two confirmations from overlapping starts is newer when
+   * host responses arrive out of order. Larger values are newer.
+   */
+  dispatchedAt: number;
 }
 
+/**
+ * Monotonic counter that stamps each `start`'s {@link
+ * ActiveAppControlSession.dispatchedAt}. Process-lifetime monotonic; the
+ * absolute value is meaningless — only ordering matters.
+ */
+let nextDispatchedAt = 1;
+
 /**
  * Currently active session, or `undefined` when no session is held. This
  * is the optimistic value: it is set the moment a `start` is dispatched
@@ -112,6 +127,13 @@ export function _getActiveAppControlSession():
   return activeAppControlSession;
 }
 
+/** Test-only helper: read the last host-confirmed session. */
+export function _getConfirmedAppControlSession():
+  | ActiveAppControlSession
+  | undefined {
+  return confirmedAppControlSession;
+}
+
 /** Test-only helper: clear both session pointers between test cases. */
 export function _resetActiveAppControlSession(): void {
   activeAppControlSession = undefined;
@@ -123,11 +145,18 @@ export function _resetActiveAppControlSession(): void {
  * round-trip. Useful for tests that exercise non-start tool paths and
  * don't need to verify the start flow itself.
  */
-export function _setActiveAppControlSession(
-  session: ActiveAppControlSession,
-): void {
-  activeAppControlSession = session;
-  confirmedAppControlSession = session;
+export function _setActiveAppControlSession(session: {
+  conversationId: string;
+  app: string;
+  dispatchedAt?: number;
+}): void {
+  const full: ActiveAppControlSession = {
+    conversationId: session.conversationId,
+    app: session.app,
+    dispatchedAt: session.dispatchedAt ?? nextDispatchedAt++,
+  };
+  activeAppControlSession = full;
+  confirmedAppControlSession = full;
 }
 
 /**
@@ -280,6 +309,7 @@ export class HostAppControlProxy extends HostProxyBase<
       attemptedSession = {
         conversationId: this.conversationId,
         app: input.app,
+        dispatchedAt: nextDispatchedAt++,
       };
       activeAppControlSession = attemptedSession;
     } else {
@@ -356,15 +386,27 @@ export class HostAppControlProxy extends HostProxyBase<
   }
 
   /**
-   * Promote this start's optimistic write to the confirmed pointer when
-   * the host returns `running`. Gated on conversation ownership rather
-   * than object identity: a newer overlapping start in the same
-   * conversation may have superseded our optimistic write while we were
-   * waiting on the host, but the host's `running` response for our
-   * `attempted` is still ground-truth that the lock should be held.
-   * The conversation-ownership check ensures we don't resurrect a session
-   * after `dispose()` cleared the lock or after another conversation
-   * acquired it.
+   * Promote this start's session to the confirmed pointer when the host
+   * returns `running`. Two gates:
+   *
+   * 1. The live optimistic write must still belong to this conversation —
+   *    if `dispose()` cleared the lock or another conversation acquired
+   *    it, this confirmation must not resurrect a stale session.
+   * 2. The confirming session must be at least as recent as the currently
+   *    confirmed one, compared via {@link
+   *    ActiveAppControlSession.dispatchedAt}. The dispatch counter is
+   *    assigned synchronously in `request()`, so it captures dispatch
+   *    order even when host responses arrive out of order. The latest
+   *    dispatched start that confirms wins, which is the right baseline
+   *    for the rollback path: if a newer start later fails, rollback
+   *    restores the most recently confirmed session, not an older one.
+   *
+   * Also advance the active pointer when it is strictly older than the
+   * newly-confirmed session. This handles the case where an even newer
+   * optimistic write has already failed and rolled active back to the
+   * previous confirmed session; without this, observe/actions for the
+   * newly-confirmed session would target the older app. A newer
+   * in-flight optimistic write (higher `dispatchedAt`) is preserved.
    */
   private promoteStartIfCurrent(
     attempted: ActiveAppControlSession | undefined,
@@ -373,7 +415,16 @@ export class HostAppControlProxy extends HostProxyBase<
     if (activeAppControlSession?.conversationId !== attempted.conversationId) {
       return;
     }
+    if (
+      confirmedAppControlSession != null &&
+      attempted.dispatchedAt <= confirmedAppControlSession.dispatchedAt
+    ) {
+      return;
+    }
     confirmedAppControlSession = attempted;
+    if (activeAppControlSession.dispatchedAt < attempted.dispatchedAt) {
+      activeAppControlSession = attempted;
+    }
   }
 
   /**

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

@@ -185,7 +185,7 @@ export class HostBashProxy extends HostProxyBase<
       timedOut: boolean;
     },
   ): void {
-    pendingInteractions.resolve(requestId);
+    pendingInteractions.resolve(requestId, "answered");
     this.resolve(requestId, response);
   }
 }

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

@@ -280,7 +280,7 @@ export class HostCuProxy {
     observation: CuObservationResult,
   ): ToolExecutionResult | undefined {
     this._ownedRequests.delete(requestId);
-    const interaction = pendingInteractions.resolve(requestId);
+    const interaction = pendingInteractions.resolve(requestId, "answered");
     if (!interaction?.rpcResolve) {
       log.warn({ requestId }, "No pending host CU request for response");
       return undefined;

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

@@ -227,7 +227,7 @@ export class HostFileProxy {
     requestId: string,
     response: { content: string; isError: boolean; imageData?: string },
   ): void {
-    const interaction = pendingInteractions.resolve(requestId);
+    const interaction = pendingInteractions.resolve(requestId, "answered");
     if (!interaction?.rpcResolve) {
       log.warn({ requestId }, "No pending host file request for response");
       return;

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

@@ -29,6 +29,9 @@
 import type { HostProxyCapability, InterfaceId } from "../channels/types.js";
 import { supportsHostProxy } from "../channels/types.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("host-proxy-preactivation");
 
 /**
  * Subset of Conversation/ProcessConversationContext that
@@ -36,9 +39,29 @@ import { assistantEventHub } from "../runtime/assistant-event-hub.js";
  * `ProcessConversationContext` satisfy this structurally.
  */
 export interface HostProxyPreactivationTarget {
+  readonly conversationId: string;
   addPreactivatedSkillId(id: string): void;
 }
 
+/**
+ * Why an attachment decision went the way it did. Logged per turn so that
+ * silent-gate failures (e.g. ATL-609: computer-use never reaches the LLM
+ * surface for a macOS user) can be diagnosed from production logs without
+ * extra instrumentation.
+ */
+export type HostProxyAttachmentReason =
+  | "native_support"
+  | "cross_client"
+  | "denied_no_interface"
+  | "denied_chrome_extension"
+  | "denied_no_clients";
+
+export interface HostProxyAttachmentDecision {
+  shouldAttach: boolean;
+  reason: HostProxyAttachmentReason;
+  clientCount?: number;
+}
+
 /**
  * Registry mapping each host-proxy capability to the skill that must be
  * preactivated when that capability is supported by the source interface.
@@ -62,45 +85,89 @@ export const HOST_PROXY_SKILL_PREACTIVATIONS: ReadonlyArray<{
 ];
 
 /**
- * Returns true when a host-proxy for the given capability should be attached
- * (instantiated and preactivated) for the current turn. Two cases qualify:
+ * Returns the full attachment decision for a host-proxy capability — used both
+ * to gate proxy instantiation and to feed the structured preactivation log so
+ * silent gates can be diagnosed without re-instrumenting after the fact.
  *
- *  1. The source interface natively supports the capability (e.g. macOS → host_cu).
- *  2. The source interface doesn't support the capability natively but at least
- *     one connected client does — cross-client routing. `chrome-extension` is
- *     excluded as a security boundary: it is its own executor context and cannot
- *     broker cross-client routing to a macOS client.
+ *  1. No source interface → `denied_no_interface`.
+ *  2. Source interface natively supports the capability → `native_support`.
+ *  3. `chrome-extension` source can never broker cross-client routing to a
+ *     macOS client (security boundary) → `denied_chrome_extension`.
+ *  4. At least one connected client advertises the capability →
+ *     `cross_client` with `clientCount`.
+ *  5. Otherwise → `denied_no_clients` with `clientCount: 0`.
  *
- * This is the single source of truth for both preactivation and proxy
- * instantiation, so the two decisions stay in sync.
+ * Single source of truth for preactivation and proxy instantiation.
+ */
+export function evaluateHostProxyAttachment(
+  capability: HostProxyCapability,
+  sourceInterface: InterfaceId | undefined,
+): HostProxyAttachmentDecision {
+  if (!sourceInterface) {
+    return { shouldAttach: false, reason: "denied_no_interface" };
+  }
+  if (supportsHostProxy(sourceInterface, capability)) {
+    return { shouldAttach: true, reason: "native_support" };
+  }
+  if (sourceInterface === "chrome-extension") {
+    return { shouldAttach: false, reason: "denied_chrome_extension" };
+  }
+  const clientCount =
+    assistantEventHub.listClientsByCapability(capability).length;
+  if (clientCount > 0) {
+    return { shouldAttach: true, reason: "cross_client", clientCount };
+  }
+  return { shouldAttach: false, reason: "denied_no_clients", clientCount: 0 };
+}
+
+/**
+ * Boolean wrapper retained for the proxy-instantiation call sites that only
+ * need the gate result. Prefer `evaluateHostProxyAttachment` when the reason
+ * is also useful (e.g. for logging or telemetry).
  */
 export function shouldAttachHostProxyForCapability(
   capability: HostProxyCapability,
   sourceInterface: InterfaceId | undefined,
 ): boolean {
-  if (!sourceInterface) return false;
-  if (supportsHostProxy(sourceInterface, capability)) return true;
-  if (sourceInterface === "chrome-extension") return false;
-  return assistantEventHub.listClientsByCapability(capability).length > 0;
+  return evaluateHostProxyAttachment(capability, sourceInterface).shouldAttach;
 }
 
 /**
  * Preactivate every host-proxy-backed skill that the given source interface
- * supports. No-op when `sourceInterface` is undefined.
+ * supports, and emit one structured `log.info` line per turn capturing each
+ * capability's decision + the final preactivated skill IDs.
+ *
+ * The log line fires unconditionally — even when `sourceInterface` is
+ * undefined — because "preactivation never ran because no interface" is
+ * itself the diagnostic signal we want visible in production.
  *
  * Callers are responsible for any additional gating (e.g. only preactivating
  * when the conversation is idle vs. when re-adding after dequeue), since
- * those constraints differ across create vs. drain paths. This helper just
- * iterates the registry and dispatches.
+ * those constraints differ across create vs. drain paths.
  */
 export function preactivateHostProxySkills(
   conversation: HostProxyPreactivationTarget,
   sourceInterface: InterfaceId | undefined,
 ): void {
-  if (!sourceInterface) return;
+  const decisions: Record<string, HostProxyAttachmentDecision> = {};
+  const preactivatedSkillIds: string[] = [];
+
   for (const { capability, skillId } of HOST_PROXY_SKILL_PREACTIVATIONS) {
-    if (shouldAttachHostProxyForCapability(capability, sourceInterface)) {
+    const decision = evaluateHostProxyAttachment(capability, sourceInterface);
+    decisions[capability] = decision;
+    if (decision.shouldAttach) {
       conversation.addPreactivatedSkillId(skillId);
+      preactivatedSkillIds.push(skillId);
     }
   }
+
+  log.info(
+    {
+      conversationId: conversation.conversationId,
+      sourceInterface,
+      decisions,
+      preactivatedSkillIds,
+    },
+    "host-proxy preactivation decision",
+  );
 }

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

@@ -508,7 +508,7 @@ export class HostTransferProxy {
       errorMessage?: string;
     },
   ): void {
-    const interaction = pendingInteractions.resolve(requestId);
+    const interaction = pendingInteractions.resolve(requestId, "answered");
     if (!interaction?.rpcResolve) {
       log.warn({ requestId }, "No pending host transfer request for response");
       return;