@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/daemon/conversation-store.ts

@@ -27,99 +27,18 @@ import { ProviderNotConfiguredError } from "../util/errors.js";
 import { getSandboxWorkingDir } from "../util/platform.js";
 import { Conversation } from "./conversation.js";
 import type { ConversationEvictor } from "./conversation-evictor.js";
+import {
+  allConversations,
+  clearConversations,
+  conversationCount,
+  conversationIds,
+  deleteConversation,
+  findConversation,
+  setConversation,
+} from "./conversation-registry.js";
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { buildTransportHints } from "./transport-hints.js";
 
-// ── Private store ──────────────────────────────────────────────────
-
-const conversations = new Map<string, Conversation>();
-
-// ── Read helpers ───────────────────────────────────────────────────
-
-export function findConversation(
-  conversationId: string,
-): Conversation | undefined {
-  return conversations.get(conversationId);
-}
-
-export function findConversationBySurfaceId(
-  surfaceId: string,
-): Conversation | undefined {
-  // Fast path: exact surfaceId match in surfaceState
-  for (const c of conversations.values()) {
-    if (c.surfaceState.has(surfaceId)) return c;
-  }
-
-  // Fallback: standalone app surfaces use "app-open-{appId}" IDs that
-  // were never part of any conversation.  Extract the appId and find
-  // a conversation whose surfaceState has a surface for that app.
-  const appOpenPrefix = "app-open-";
-  if (surfaceId.startsWith(appOpenPrefix)) {
-    const appId = surfaceId.slice(appOpenPrefix.length);
-    for (const c of conversations.values()) {
-      for (const [, state] of c.surfaceState.entries()) {
-        const data = state.data as unknown as Record<string, unknown>;
-        if (data?.appId === appId) {
-          // Register this surfaceId so subsequent lookups are O(1)
-          c.surfaceState.set(surfaceId, state);
-          return c;
-        }
-      }
-    }
-  }
-
-  return undefined;
-}
-
-function conversationCount(): number {
-  return conversations.size;
-}
-
-/** Iterate over all active conversations. */
-export function allConversations(): IterableIterator<Conversation> {
-  return conversations.values();
-}
-
-/** Iterate over all [id, conversation] entries. */
-export function conversationEntries(): IterableIterator<
-  [string, Conversation]
-> {
-  return conversations.entries();
-}
-
-/** Iterate over all active conversation IDs. */
-function conversationIds(): IterableIterator<string> {
-  return conversations.keys();
-}
-
-// ── Write helpers ──────────────────────────────────────────────────
-
-export function setConversation(
-  conversationId: string,
-  conversation: Conversation,
-): void {
-  conversations.set(conversationId, conversation);
-}
-
-export function deleteConversation(conversationId: string): boolean {
-  return conversations.delete(conversationId);
-}
-
-export function clearConversations(): void {
-  conversations.clear();
-}
-
-// ── Underlying Map (for the evictor, which takes a mutable ref) ───
-
-/**
- * Expose the raw Map for the {@link ConversationEvictor}, which needs
- * a mutable reference to delete entries during sweeps. No other code
- * should use this — prefer the named helpers above.
- */
-export function getConversationMap(): Map<string, Conversation> {
-  return conversations;
-}
-
 // ── Per-conversation persistent options ────────────────────────────
 
 const conversationOptions = new Map<string, ConversationCreateOptions>();

package/src/daemon/conversation-surfaces.ts

@@ -1,5 +1,6 @@
 import { v4 as uuid } from "uuid";
 
+import { isActivationSession } from "../memory/activation-session-store.js";
 import {
   addAppConversationId,
   getApp,
@@ -14,6 +15,7 @@ import {
   getMessages,
   updateMessageContent,
 } from "../memory/conversation-crud.js";
+import { recordActivationEvent } from "../memory/onboarding-events-store.js";
 import {
   assistantEventHub,
   broadcastMessage,
@@ -23,10 +25,17 @@ import {
   enforceSameActorOrErrorResult,
   pickSameUserAutoResolve,
 } from "../runtime/auth/same-actor.js";
+import type { AuthContext } from "../runtime/auth/types.js";
 import type {
   InteractiveUiRequest,
   InteractiveUiResult,
 } from "../runtime/interactive-ui-types.js";
+import {
+  activationMomentEmitsAtShow,
+  type ActivationMomentParam,
+  activationStepNameForMomentParam,
+  isActivationMomentParam,
+} from "../telemetry/activation-funnel.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { isPlainObject } from "../util/object.js";
@@ -544,6 +553,12 @@ export interface SurfaceConversationContext {
   readonly assistantId?: string;
   /** Inherited to spawned conversations in the `launch_conversation` action path. */
   readonly trustContext?: TrustContext;
+  /** Verified requester auth context for the active turn. */
+  readonly authContext?: AuthContext;
+  /** Per-turn auth snapshot, preferred for tool dispatch authorization. */
+  readonly currentTurnAuthContext?: AuthContext;
+  /** JWT-verified requester principal for the active turn. */
+  readonly currentTurnSourceActorPrincipalId?: string;
   readonly channelCapabilities?: {
     channel: string;
     supportsDynamicUi: boolean;
@@ -569,6 +584,14 @@ export interface SurfaceConversationContext {
         style?: string;
         data?: Record<string, unknown>;
       }>;
+      /**
+       * Activation-rail telemetry tag (daemon-only). When the model tags a
+       * `ui_show` surface as an activation funnel moment, the token is captured
+       * here so the milestone can be recorded deterministically when the user
+       * commits the surface (`handleSurfaceAction`). Never forwarded to the
+       * client.
+       */
+      activationMoment?: ActivationMomentParam;
     }
   >;
   surfaceUndoStacks: Map<string, string[]>;
@@ -613,6 +636,12 @@ export interface SurfaceConversationContext {
     display?: string;
     persistent?: boolean;
     toolCallId?: string;
+    /**
+     * Commit-timing activation-rail tag (daemon-only). Carried through to the
+     * persisted `ui_surface` history block so it survives a reload — never sent
+     * to the client.
+     */
+    activationMoment?: ActivationMomentParam;
   }>;
   /** Optional proxy for delegating computer-use actions to a connected desktop client. */
   hostCuProxy?: HostCuProxy;
@@ -1250,6 +1279,60 @@ function getRequestedSurfaceCompletionSummary(
   return summary || "Completed";
 }
 
+/**
+ * Best-effort recorder for a single activation-funnel moment. Gated on the
+ * conversation being a marked activation-rail session. Fire-and-forget: never
+ * throws, never blocks or alters the surface-action flow (a failure is logged
+ * and swallowed). Shared by the show-time path (`first_wow_executed`, recorded
+ * when the surface renders) and the commit-time path (the other moments,
+ * recorded when the user commits the surface).
+ */
+function recordActivationMoment(
+  ctx: SurfaceConversationContext,
+  moment: ActivationMomentParam,
+): void {
+  try {
+    if (!isActivationSession(ctx.conversationId)) return;
+    recordActivationEvent({
+      stepName: activationStepNameForMomentParam(moment),
+      sessionId: ctx.conversationId,
+    });
+  } catch (err) {
+    log.warn(
+      { err, conversationId: ctx.conversationId, moment },
+      "Failed to record activation moment",
+    );
+  }
+}
+
+/**
+ * Best-effort activation-funnel emission on a user surface commit.
+ *
+ * When the committed surface carries a commit-timing `activationMoment` tag,
+ * record the corresponding funnel milestone. Show-timing moments
+ * (`first_wow_executed`) are recorded at render time in `surfaceProxyResolver`
+ * and are NOT stored on `surfaceState`, so they never reach this path. The tag
+ * is cleared after the first record so re-entrant or repeated commits on the
+ * same surface do not double-emit (and the deterministic `daemon_event_id`
+ * collapses any cross-surface duplicate downstream anyway).
+ *
+ * Must be called only from terminal-commit paths (user clicked an action /
+ * submitted / selected-and-committed), NOT from intermediate non-terminal
+ * events (`selection_changed` / `content_changed` / `state_update`).
+ */
+function maybeEmitActivationMoment(
+  ctx: SurfaceConversationContext,
+  surfaceId: string,
+): void {
+  const stored = ctx.surfaceState.get(surfaceId);
+  const moment = stored?.activationMoment;
+  if (!moment) return;
+  // Clear the tag first so this can fire at most once per surface even if the
+  // commit path is re-entered.
+  stored.activationMoment = undefined;
+  recordActivationMoment(ctx, moment);
+}
+
 function completeSurfaceFromAction(
   ctx: SurfaceConversationContext,
   surfaceId: string,
@@ -1317,6 +1400,13 @@ export async function handleSurfaceAction(
     });
     markSurfaceCompleted(ctx, surfaceId, summary);
 
+    // Terminal user commit on a standalone surface (submit, not cancel/dismiss)
+    // — record an activation milestone if tagged. Must run before
+    // `cleanupStandaloneSurface` clears the surface state.
+    if (!isCancellation) {
+      maybeEmitActivationMoment(ctx, surfaceId);
+    }
+
     // Cleanup and resolve — order matters: cleanup clears the timer
     // before resolve() unblocks the caller.
     cleanupStandaloneSurface(ctx, surfaceId);
@@ -1403,6 +1493,10 @@ export async function handleSurfaceAction(
       { originConversationId: ctx.conversationId, conversationId, surfaceId },
       "launch_conversation dispatched inline from surface action",
     );
+    // Launching a child conversation is a terminal user commit — record an
+    // activation milestone if tagged. The helper clears the tag after firing,
+    // so the other commit-path call sites below can't double-emit.
+    maybeEmitActivationMoment(ctx, surfaceId);
     return { accepted: true, conversationId };
   }
 
@@ -1557,6 +1651,12 @@ export async function handleSurfaceAction(
       return;
     }
 
+    // Terminal user commit accepted — record the activation milestone if this
+    // surface was tagged (best-effort, no-op otherwise). Deferred until after
+    // the rejection check so a queue-full click doesn't over-report a moment
+    // (and the one-shot tag stays intact for the user's retry).
+    maybeEmitActivationMoment(ctx, surfaceId);
+
     const requestedCompletionSummary =
       getRequestedSurfaceCompletionSummary(mergedData);
     if (requestedCompletionSummary) {
@@ -1796,6 +1896,12 @@ export async function handleSurfaceAction(
     return;
   }
 
+  // Terminal user commit accepted — record the activation milestone if this
+  // surface was tagged (best-effort, no-op otherwise). Deferred until after the
+  // rejection check so a queue-full click doesn't over-report a moment (and the
+  // one-shot tag stays intact for the user's retry).
+  maybeEmitActivationMoment(ctx, surfaceId);
+
   const requestedCompletionSummary =
     getRequestedSurfaceCompletionSummary(mergedData);
 
@@ -1960,6 +2066,15 @@ export function refreshSurfacesForApp(
   return refreshed;
 }
 
+/**
+ * Strip a leading "Connect "/"Connected " verb from an OAuth provider label so
+ * a supplied displayName like "Connect Gmail" doesn't double the verb when
+ * prefixed (e.g. avoids "Connected Connect Gmail").
+ */
+function stripConnectVerb(label: string): string {
+  return label.replace(/^connect(?:ed)?\s+/i, "");
+}
+
 export function buildCompletionSummary(
   surfaceType: string | undefined,
   actionId: string,
@@ -2026,20 +2141,24 @@ export function buildCompletionSummary(
           : typeof data?.providerKey === "string"
             ? data.providerKey
             : "OAuth";
+    // Strip the verb once so every branch (connected/cancelled/failed/
+    // fallback) is normalized — a displayName like "Connect Gmail" must not
+    // produce "Cancelled Connect Gmail connection".
+    const label = stripConnectVerb(providerLabel);
     const accountLabel =
       typeof data?.accountLabel === "string" ? data.accountLabel : undefined;
     if (actionId === "connect" || data?.status === "connected") {
       return accountLabel
-        ? `Connected ${providerLabel}: ${accountLabel}`
-        : `Connected ${providerLabel}`;
+        ? `Connected ${label}: ${accountLabel}`
+        : `Connected ${label}`;
     }
     if (actionId === "cancel" || data?.status === "cancelled") {
-      return `Cancelled ${providerLabel} connection`;
+      return `Cancelled ${label} connection`;
     }
     if (data?.status === "error") {
-      return `${providerLabel} connection failed`;
+      return `${label} connection failed`;
     }
-    return `${providerLabel} connection ${actionId}`;
+    return `${label} connection ${actionId}`;
   }
   if (surfaceType === "list" && data) {
     const selectedIds = data.selectedIds as string[] | undefined;
@@ -2120,18 +2239,21 @@ function buildUserFacingLabel(
           : typeof data?.providerKey === "string"
             ? data.providerKey
             : "OAuth";
+    // Strip the verb once so every branch is normalized (e.g. a displayName
+    // like "Connect Gmail" must not produce "Connect Gmail connection failed").
+    const label = stripConnectVerb(providerLabel);
     const accountLabel =
       typeof data?.accountLabel === "string" ? data.accountLabel : undefined;
     if (actionId === "connect" || data?.status === "connected") {
       return accountLabel
-        ? `Connected ${providerLabel}: ${accountLabel}`
-        : `Connected ${providerLabel}`;
+        ? `Connected ${label}: ${accountLabel}`
+        : `Connected ${label}`;
     }
     if (actionId === "cancel" || data?.status === "cancelled") {
       return "Cancelled";
     }
     if (data?.status === "error") {
-      return `${providerLabel} connection failed`;
+      return `${label} connection failed`;
     }
     return `Selected: ${actionId}`;
   }
@@ -2199,7 +2321,10 @@ export async function surfaceProxyResolver(
     // validate at the tool-resolution layer for the same reason. The proxy
     // re-checks same-user (single authoritative gate); using the shared
     // helper keeps log payload and error wording identical at both layers.
-    const sourceActorPrincipalId = ctx.trustContext?.guardianPrincipalId;
+    const sourceActorPrincipalId =
+      ctx.currentTurnSourceActorPrincipalId ??
+      ctx.currentTurnAuthContext?.actorPrincipalId ??
+      ctx.authContext?.actorPrincipalId;
     if (targetClientId != null) {
       const client = assistantEventHub.getClientById(targetClientId);
       if (!client) {
@@ -2305,7 +2430,10 @@ export async function surfaceProxyResolver(
         ? input.target_client_id
         : undefined;
 
-    const sourceActorPrincipalId = ctx.trustContext?.guardianPrincipalId;
+    const sourceActorPrincipalId =
+      ctx.currentTurnSourceActorPrincipalId ??
+      ctx.currentTurnAuthContext?.actorPrincipalId ??
+      ctx.authContext?.actorPrincipalId;
     if (targetClientId != null) {
       const client = assistantEventHub.getClientById(targetClientId);
       if (!client) {
@@ -2488,6 +2616,24 @@ export async function surfaceProxyResolver(
       ...(a.data ? { data: a.data } : {}),
     }));
 
+    // Optional activation-rail telemetry tag. Daemon-only metadata: validated
+    // and ignored if invalid; never forwarded to the client.
+    const activationMoment =
+      typeof input.activation_moment === "string" &&
+      isActivationMomentParam(input.activation_moment)
+        ? input.activation_moment
+        : undefined;
+
+    // Show-timing moments (`first_wow_executed`) record the instant the surface
+    // renders — a display-only result/`work_result` card may never be committed,
+    // so a commit-time emit would never fire. We record now and do NOT store the
+    // tag, so the commit path won't double-emit. Commit-timing moments are
+    // stored and recorded when the user commits the surface (see
+    // `handleSurfaceAction` → `maybeEmitActivationMoment`).
+    const storeTagForCommit =
+      activationMoment !== undefined &&
+      !activationMomentEmitsAtShow(activationMoment);
+
     // Track surface state for ui_update merging (includes actions so we can
     // look up per-action data payloads when the client sends an action back).
     ctx.surfaceState.set(surfaceId, {
@@ -2495,8 +2641,13 @@ export async function surfaceProxyResolver(
       data,
       title,
       actions: mappedActions,
+      ...(storeTagForCommit ? { activationMoment } : {}),
     });
 
+    if (activationMoment !== undefined && !storeTagForCommit) {
+      recordActivationMoment(ctx, activationMoment);
+    }
+
     log.info(
       {
         surfaceId,
@@ -2524,7 +2675,9 @@ export async function surfaceProxyResolver(
       ...(toolUseId ? { toolCallId: toolUseId } : {}),
     } as unknown as UiSurfaceShow);
 
-    // Track surface for persistence with the message
+    // Track surface for persistence with the message. The commit-timing
+    // activation tag rides along (daemon-only) so it survives history restore;
+    // show-timing moments aren't stored here (already recorded at render).
     ctx.currentTurnSurfaces.push({
       surfaceId,
       surfaceType,
@@ -2534,6 +2687,7 @@ export async function surfaceProxyResolver(
       display,
       ...(persistent ? { persistent: true } : {}),
       ...(toolUseId ? { toolCallId: toolUseId } : {}),
+      ...(storeTagForCommit ? { activationMoment } : {}),
     });
 
     if (awaitAction) {

package/src/daemon/conversation-workspace.ts

@@ -4,6 +4,7 @@ import { getConversation } from "../memory/conversation-crud.js";
 import { resolveConversationDirectoryPaths } from "../memory/conversation-directories.js";
 import { renderWorkspaceTopLevelContext } from "../workspace/top-level-renderer.js";
 import { scanTopLevelDirectories } from "../workspace/top-level-scanner.js";
+import { findConversationOrSubagent } from "./conversation-registry.js";
 
 /**
  * Subset of Conversation state that workspace context helpers need.
@@ -25,6 +26,22 @@ export interface WorkspaceConversationContext {
   hostUsername?: string;
 }
 
+/**
+ * Resolve the live workspace top-level block for a conversation, refreshing
+ * the dirty-guarded cache first so a workspace-mutating tool's
+ * `markWorkspaceTopLevelDirty` from the prior turn is picked up. Returns `null`
+ * when no live conversation is found (no active conversation, or a context with
+ * no conversation id) or when the rendered context is empty.
+ */
+export function resolveWorkspaceTopLevelContext(
+  conversationId: string | undefined,
+): string | null {
+  const conversation = findConversationOrSubagent(conversationId);
+  if (!conversation) return null;
+  refreshWorkspaceTopLevelContextIfNeeded(conversation);
+  return conversation.workspaceTopLevelContext;
+}
+
 /** Refresh workspace top-level directory context if needed. */
 export function refreshWorkspaceTopLevelContextIfNeeded(
   ctx: WorkspaceConversationContext,