@vellumai/assistant 0.5.1 → 0.5.3

package/src/daemon/conversation-surfaces.ts

@@ -1,6 +1,11 @@
 import { v4 as uuid } from "uuid";
 
-import { getApp, getAppPreview, updateApp } from "../memory/app-store.js";
+import {
+  getApp,
+  getAppPreview,
+  resolveAppDir,
+  updateApp,
+} from "../memory/app-store.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { isPlainObject } from "../util/object.js";
@@ -167,6 +172,7 @@ export interface SurfaceConversationContext {
     emit(type: string, message: string, meta?: Record<string, unknown>): void;
   };
   sendToClient(msg: ServerMessage): void;
+  broadcastToAllClients?(msg: ServerMessage): void;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
   lastSurfaceAction: Map<
     string,
@@ -187,6 +193,7 @@ export interface SurfaceConversationContext {
     }
   >;
   surfaceUndoStacks: Map<string, string[]>;
+  accumulatedSurfaceState: Map<string, Record<string, unknown>>;
   /** Request IDs that originated from surface action button clicks (not regular user messages). */
   surfaceActionRequestIds: Set<string>;
   currentTurnSurfaces: Array<{
@@ -346,6 +353,39 @@ function handleDocumentContentChanged(
   }
 }
 
+/**
+ * Handle state_update action from a dynamic page.
+ * Accumulates state via shallow merge without triggering an LLM turn.
+ */
+function handleStateUpdate(
+  ctx: SurfaceConversationContext,
+  surfaceId: string,
+  data?: Record<string, unknown>,
+): void {
+  if (!data) {
+    log.debug({ surfaceId }, "state_update action called with no data");
+    return;
+  }
+
+  const surfaceState = ctx.surfaceState.get(surfaceId);
+  if (!surfaceState || surfaceState.surfaceType !== "dynamic_page") {
+    log.warn(
+      { surfaceId, surfaceType: surfaceState?.surfaceType },
+      "state_update action received for non-dynamic_page surface",
+    );
+    return;
+  }
+
+  const existing = ctx.accumulatedSurfaceState.get(surfaceId) ?? {};
+  const merged = { ...existing, ...data };
+  ctx.accumulatedSurfaceState.set(surfaceId, merged);
+
+  log.debug(
+    { surfaceId, accumulatedState: merged },
+    "Accumulated surface state updated",
+  );
+}
+
 export function pushUndoState(
   surfaceUndoStacks: Map<string, string[]>,
   surfaceId: string,
@@ -543,22 +583,76 @@ export function handleSurfaceAction(
   const pending = ctx.pendingSurfaceActions.get(surfaceId);
 
   // When surfaces are restored from history (e.g. onboarding cards), there is
-  // no in-memory pendingSurfaceActions entry.  For relay_prompt / agent_prompt
-  // actions the client already sends the full payload (including { prompt }),
-  // so we can handle them without stored state.
+  // no in-memory pendingSurfaceActions entry.  Handle non-terminal actions
+  // directly, and forward custom/relay actions to the LLM.
   if (!pending) {
+    // Non-terminal actions don't need stored state — handle directly.
+    if (actionId === "selection_changed") {
+      log.debug(
+        { surfaceId, data },
+        "Selection changed (history-restored, not forwarding)",
+      );
+      return;
+    }
+    if (actionId === "content_changed") {
+      log.debug(
+        { surfaceId },
+        "Content changed (history-restored, no surface state — skipping)",
+      );
+      return;
+    }
+    if (actionId === "state_update") {
+      if (data) {
+        const existing = ctx.accumulatedSurfaceState.get(surfaceId) ?? {};
+        ctx.accumulatedSurfaceState.set(surfaceId, { ...existing, ...data });
+      }
+      log.debug(
+        { surfaceId, data },
+        "Silent state accumulated (history-restored)",
+      );
+      return;
+    }
+
+    // Determine message content from the action.
     const isRelay = actionId === "relay_prompt" || actionId === "agent_prompt";
     const prompt =
       isRelay && typeof data?.prompt === "string" ? data.prompt.trim() : "";
 
-    if (!prompt) {
-      log.warn({ surfaceId, actionId }, "No pending surface action found");
-      return;
+    // Read accumulated state once — used by both relay and custom action paths.
+    const accState = ctx.accumulatedSurfaceState.get(surfaceId);
+    const hasAccState = accState && Object.keys(accState).length > 0;
+
+    let content: string;
+    let displayContent: string | undefined;
+    if (prompt) {
+      content = prompt;
+      // Re-append accumulated state so the LLM sees it, matching the pending path.
+      if (hasAccState) {
+        content += `\n\nAccumulated surface state: ${JSON.stringify(accState)}`;
+      }
+    } else {
+      // Custom action from an app (e.g. sendAction('answer_selected', {...}))
+      const summary = actionId
+        .replace(/_/g, " ")
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+      content = `[User action on app: ${summary}]`;
+      if (data && Object.keys(data).length > 0) {
+        content += `\n\nAction data: ${JSON.stringify(data)}`;
+      }
+      if (hasAccState) {
+        content += `\n\nAccumulated surface state: ${JSON.stringify(accState)}`;
+      }
+      displayContent = summary;
     }
 
     const requestId = uuid();
     ctx.surfaceActionRequestIds.add(requestId);
-    const onEvent = (msg: ServerMessage) => ctx.sendToClient(msg);
+    // Use broadcastToAllClients (publishes to the SSE event hub) instead of
+    // sendToClient, which is reset to a no-op between HTTP requests. Without
+    // this, surface action responses are persisted to DB but never reach the
+    // client's SSE stream.
+    const emit = ctx.broadcastToAllClients ?? ctx.sendToClient.bind(ctx);
+    const onEvent = (msg: ServerMessage) => emit(msg);
 
     ctx.traceEmitter.emit("request_received", "Surface action received", {
       requestId,
@@ -567,11 +661,15 @@ export function handleSurfaceAction(
     });
 
     const result = ctx.enqueueMessage(
-      prompt,
+      content,
       [],
       onEvent,
       requestId,
       surfaceId,
+      undefined,
+      undefined,
+      undefined,
+      displayContent,
     );
 
     if (result.rejected) {
@@ -579,18 +677,26 @@ export function handleSurfaceAction(
       return;
     }
 
+    // One-shot: clear accumulated state now that the message has been accepted.
+    // Deferred until after rejection check so state is preserved for retry on rejection.
+    if (hasAccState) {
+      ctx.accumulatedSurfaceState.delete(surfaceId);
+    }
+
     // Echo the prompt to the client so it appears in the chat UI.
     // Deferred until after rejection check to avoid ghost messages.
-    ctx.sendToClient({
-      type: "user_message_echo",
-      text: prompt,
-      conversationId: ctx.conversationId,
-    });
+    if (prompt) {
+      emit({
+        type: "user_message_echo",
+        text: prompt,
+        conversationId: ctx.conversationId,
+      });
+    }
 
     if (result.queued) {
       log.info(
         { surfaceId, actionId, requestId },
-        "Relay prompt queued (conversation busy, history-restored)",
+        "Surface action queued (conversation busy, history-restored)",
       );
       return;
     }
@@ -598,22 +704,31 @@ export function handleSurfaceAction(
     // Conversation is idle — process the message immediately.
     log.info(
       { surfaceId, actionId, requestId },
-      "Processing relay prompt immediately (history-restored)",
+      "Processing surface action immediately (history-restored)",
     );
     ctx
-      .processMessage(prompt, [], onEvent, requestId, surfaceId)
+      .processMessage(
+        content,
+        [],
+        onEvent,
+        requestId,
+        surfaceId,
+        undefined,
+        undefined,
+        displayContent,
+      )
       .catch((err) => {
         const message = err instanceof Error ? err.message : String(err);
         log.error(
           { err, surfaceId, actionId },
-          "Failed to process history-restored relay prompt",
+          "Failed to process history-restored surface action",
         );
         onEvent(
           buildConversationErrorMessage(ctx.conversationId, {
             code: "CONVERSATION_PROCESSING_FAILED",
             userMessage: `Something went wrong: ${message}`,
             retryable: false,
-            debugDetails: `History-restored relay prompt processing failed: ${message}`,
+            debugDetails: `History-restored surface action processing failed: ${message}`,
             errorCategory: "processing_failed",
           }),
         );
@@ -637,6 +752,14 @@ export function handleSurfaceAction(
     handleDocumentContentChanged(ctx, surfaceId, data);
     return;
   }
+
+  // state_update is a silent accumulation action — merge data into accumulated
+  // state without triggering an LLM turn.
+  if (actionId === "state_update") {
+    handleStateUpdate(ctx, surfaceId, data);
+    return;
+  }
+
   // Merge stored action-level data (from ui_show definition) with client-sent
   // data. This is critical for relay_prompt buttons: the client only sends the
   // actionId, but the prompt payload lives in the action definition's data.
@@ -663,11 +786,16 @@ export function handleSurfaceAction(
     surfaceData,
   );
 
+  // Use broadcastToAllClients so events reach the SSE hub — sendToClient is
+  // reset to a no-op between HTTP requests (see history-restored path for
+  // full rationale).
+  const emit = ctx.broadcastToAllClients ?? ctx.sendToClient.bind(ctx);
+
   // Forms are one-shot surfaces — auto-complete immediately so the client
   // transitions from the "Submitting…" spinner to a completion chip without
   // requiring the LLM to call ui_dismiss.
   if (pending.surfaceType === "form") {
-    ctx.sendToClient({
+    emit({
       type: "ui_surface_complete",
       conversationId: ctx.conversationId,
       surfaceId,
@@ -694,6 +822,10 @@ export function handleSurfaceAction(
       selectedIds,
     );
   }
+  const accumulatedState = ctx.accumulatedSurfaceState.get(surfaceId);
+  if (accumulatedState && Object.keys(accumulatedState).length > 0) {
+    fallbackContent += `\n\nAccumulated surface state: ${JSON.stringify(accumulatedState)}`;
+  }
   // When a relay_prompt button also carries selection data (e.g. list/table
   // surface with a canned prompt + user-selected rows), append the selection
   // context so the LLM sees both the prompt and the user's selections.
@@ -707,6 +839,11 @@ export function handleSurfaceAction(
       );
     }
   }
+  // When prompt is truthy, fallbackContent (which includes accumulated state)
+  // is discarded. Re-append accumulated state so the LLM sees it.
+  if (prompt && accumulatedState && Object.keys(accumulatedState).length > 0) {
+    content += `\n\nAccumulated surface state: ${JSON.stringify(accumulatedState)}`;
+  }
   // Show the user plain-text instead of raw JSON action data.
   const displayContent = prompt
     ? undefined
@@ -719,7 +856,7 @@ export function handleSurfaceAction(
 
   const requestId = uuid();
   ctx.surfaceActionRequestIds.add(requestId);
-  const onEvent = (msg: ServerMessage) => ctx.sendToClient(msg);
+  const onEvent = (msg: ServerMessage) => emit(msg);
 
   ctx.traceEmitter.emit("request_received", "Surface action received", {
     requestId,
@@ -743,10 +880,16 @@ export function handleSurfaceAction(
     return;
   }
 
+  // One-shot: clear accumulated state now that the message has been accepted.
+  // Deferred until after rejection check so state is preserved for retry on rejection.
+  if (accumulatedState && Object.keys(accumulatedState).length > 0) {
+    ctx.accumulatedSurfaceState.delete(surfaceId);
+  }
+
   // Echo the user's prompt to the client so it appears in the chat UI.
   // Deferred until after rejection check to avoid ghost messages.
   if (shouldRelayPrompt && prompt) {
-    ctx.sendToClient({
+    emit({
       type: "user_message_echo",
       text: prompt,
       conversationId: ctx.conversationId,
@@ -811,7 +954,7 @@ export function handleSurfaceAction(
 }
 
 /**
- * After an app_update, refresh any active surface that displays the updated app.
+ * After an app_refresh, refresh any active surface that displays the updated app.
  */
 export function refreshSurfacesForApp(
   ctx: SurfaceConversationContext,
@@ -860,7 +1003,7 @@ export function refreshSurfacesForApp(
     refreshed = true;
     log.info(
       { conversationId: ctx.conversationId, surfaceId, appId },
-      "Auto-refreshed surface after app_update",
+      "Auto-refreshed surface after app_refresh",
     );
   }
   return refreshed;
@@ -1201,6 +1344,7 @@ export async function surfaceProxyResolver(
     ctx.surfaceState.delete(surfaceId);
     ctx.surfaceUndoStacks.delete(surfaceId);
     ctx.lastSurfaceAction.delete(surfaceId);
+    ctx.accumulatedSurfaceState.delete(surfaceId);
     return {
       content: lastAction ? "Surface completed" : "Surface dismissed",
       isError: false,
@@ -1219,9 +1363,11 @@ export async function surfaceProxyResolver(
     const defaultPreview = { title: app.name, subtitle: app.description };
 
     const storedPreview = getAppPreview(app.id);
+    const { dirName } = resolveAppDir(app.id);
     const surfaceData: DynamicPageSurfaceData = {
       html: app.htmlDefinition,
       appId: app.id,
+      dirName,
       preview: {
         ...defaultPreview,
         ...preview,

package/src/daemon/conversation-tool-setup.ts

@@ -560,8 +560,6 @@ export interface SkillProjectionContext {
   };
   /** True when no client is connected (HTTP-only). */
   readonly hasNoClient?: boolean;
-  /** True when the conversation has user-uploaded attachments. */
-  hasAttachments?: boolean;
 }
 
 // ── Conditional tool sets ────────────────────────────────────────────
@@ -573,7 +571,6 @@ const HOST_TOOL_NAMES = new Set([
   "host_file_edit",
   "host_bash",
 ]);
-const ASSET_TOOL_NAMES = new Set(["asset_search", "asset_materialize"]);
 const CLIENT_CAPABILITY_TOOL_NAMES = new Set(["app_open"]);
 const PLATFORM_TOOL_NAMES = new Set(["request_system_permission"]);
 
@@ -597,9 +594,6 @@ export function isToolActiveForContext(
     // unchecked host command execution on the daemon host.
     return !ctx.hasNoClient;
   }
-  if (ASSET_TOOL_NAMES.has(name)) {
-    return ctx.hasAttachments ?? false;
-  }
   if (CLIENT_CAPABILITY_TOOL_NAMES.has(name)) {
     return !ctx.hasNoClient;
   }

package/src/daemon/conversation-workspace.ts

@@ -1,3 +1,7 @@
+import { join } from "node:path";
+
+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";
 
@@ -5,6 +9,7 @@ import { scanTopLevelDirectories } from "../workspace/top-level-scanner.js";
  * Subset of Conversation state that workspace context helpers need.
  */
 export interface WorkspaceConversationContext {
+  conversationId: string;
   workingDir: string;
   workspaceTopLevelContext: string | null;
   workspaceTopLevelDirty: boolean;
@@ -17,6 +22,21 @@ export function refreshWorkspaceTopLevelContextIfNeeded(
   if (!ctx.workspaceTopLevelDirty && ctx.workspaceTopLevelContext != null)
     return;
   const snapshot = scanTopLevelDirectories(ctx.workingDir);
-  ctx.workspaceTopLevelContext = renderWorkspaceTopLevelContext(snapshot);
+  const conversation = getConversation(ctx.conversationId);
+  let currentConversationPath: string | null = null;
+  if (conversation && typeof conversation.createdAt === "number") {
+    const { resolvedDirName } = resolveConversationDirectoryPaths(
+      conversation.id,
+      conversation.createdAt,
+      join(ctx.workingDir, "conversations"),
+    );
+    currentConversationPath = `conversations/${resolvedDirName}/`;
+  }
+  ctx.workspaceTopLevelContext = renderWorkspaceTopLevelContext(snapshot, {
+    currentConversationPath,
+    currentConversationAttachmentsPath: currentConversationPath
+      ? `${currentConversationPath}attachments/`
+      : null,
+  });
   ctx.workspaceTopLevelDirty = false;
 }

package/src/daemon/conversation.ts

@@ -81,7 +81,6 @@ import type {
   ChannelCapabilities,
   TrustContext,
 } from "./conversation-runtime-assembly.js";
-import { messagesContainAttachments } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import {
   createSurfaceMutex,
@@ -164,7 +163,6 @@ export class Conversation {
   /** @internal */ contextCompactedAt: number | null = null;
   /** @internal */ currentRequestId?: string;
   /** @internal */ hasNoClient = false;
-  /** @internal */ hasAttachments = false;
   /** @internal */ headlessLock = false;
   /** @internal */ taskRunId?: string;
   /** @internal */ callSessionId?: string;
@@ -197,9 +195,24 @@ export class Conversation {
   >();
   /** @internal */ surfaceState = new Map<
     string,
-    { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    {
+      surfaceType: SurfaceType;
+      data: SurfaceData;
+      title?: string;
+      actions?: Array<{
+        id: string;
+        label: string;
+        style?: string;
+        data?: Record<string, unknown>;
+      }>;
+    }
   >();
   /** @internal */ surfaceUndoStacks = new Map<string, string[]>();
+  /** @internal */ accumulatedSurfaceState = new Map<
+    string,
+    Record<string, unknown>
+  >();
+  /** @internal */ broadcastToAllClients?: (msg: ServerMessage) => void;
   /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{
     surfaceId: string;
@@ -246,6 +259,7 @@ export class Conversation {
     this.provider = provider;
     this.workingDir = workingDir;
     this.sendToClient = sendToClient;
+    this.broadcastToAllClients = broadcastToAllClients;
     this.memoryPolicy = memoryPolicy
       ? { ...memoryPolicy }
       : { ...DEFAULT_MEMORY_POLICY };
@@ -379,13 +393,41 @@ export class Conversation {
 
   async loadFromDb(): Promise<void> {
     await loadFromDbImpl(this);
-    // Scan loaded history for attachment content blocks so that asset
-    // tools are available when resuming a conversation that already had
-    // attachments. One-way: once true it stays true for the conversation.
-    // Also picks up the hasAttachments flag set by loadFromDbImpl which
-    // scans compacted (sliced-off) messages that aren't in this.messages.
-    if (!this.hasAttachments && messagesContainAttachments(this.messages)) {
-      this.hasAttachments = true;
+    this.restoreSurfaceStateFromHistory();
+  }
+
+  /**
+   * Scan loaded conversation history for ui_surface content blocks and
+   * populate surfaceState so that findConversationBySurfaceId works for
+   * surfaces restored from history (e.g. after daemon restart).
+   *
+   * Only scans live (non-compacted) messages in this.messages — not all DB
+   * rows — because surface IDs are not globally unique and restoring stale
+   * compacted surfaces would let findConversationBySurfaceId route actions
+   * to the wrong conversation.
+   */
+  private restoreSurfaceStateFromHistory(): void {
+    this.surfaceState.clear();
+    for (const msg of this.messages) {
+      if (!Array.isArray(msg.content)) continue;
+      for (const block of msg.content) {
+        const b = block as unknown as Record<string, unknown>;
+        if (b.type === "ui_surface" && typeof b.surfaceId === "string") {
+          this.surfaceState.set(b.surfaceId, {
+            surfaceType: (b.surfaceType ?? "dynamic_page") as SurfaceType,
+            data: (b.data ?? {}) as SurfaceData,
+            title: b.title as string | undefined,
+            actions: Array.isArray(b.actions)
+              ? (b.actions as Array<{
+                  id: string;
+                  label: string;
+                  style?: string;
+                  data?: Record<string, unknown>;
+                }>)
+              : undefined,
+          });
+        }
+      }
     }
   }
 
@@ -606,6 +648,18 @@ export class Conversation {
       "Resuming after approval",
     );
 
+    // Sync the canonical guardian request status so stale "pending" DB
+    // records don't get matched by later guardian reply routing. Best-effort:
+    // CAS may harmlessly fail if the canonical decision primitive already
+    // resolved the request (e.g. channel approval path).
+    try {
+      resolveCanonicalGuardianRequest(requestId, "pending", {
+        status: resolvedState,
+      });
+    } catch {
+      // Canonical request tracking should not break the primary approval flow.
+    }
+
     // Cascade to other pending confirmations that match this decision
     this.cascadePendingApprovals(requestId, decision, selectedPattern);
   }
@@ -648,10 +702,11 @@ export class Conversation {
       // Consume from pending-interactions tracker
       pendingInteractions.resolve(candidateId);
 
-      // Resolve via handleConfirmationResponse which emits events.
-      // Use simple "allow"/"deny" so the permission-checker won't save
-      // duplicate rules or re-activate temporary modes. Recursion
-      // terminates because allow/deny exit cascadePendingApprovals early.
+      // Resolve via handleConfirmationResponse which emits events and
+      // syncs canonical status. Use simple "allow"/"deny" so the
+      // permission-checker won't save duplicate rules or re-activate
+      // temporary modes. Recursion terminates because allow/deny exit
+      // cascadePendingApprovals early.
       this.handleConfirmationResponse(
         candidateId,
         cascadeResult.allow ? "allow" : "deny",
@@ -663,17 +718,6 @@ export class Conversation {
           causedByRequestId: primaryRequestId,
         },
       );
-
-      // Sync the canonical guardian request status for the cascaded request.
-      // Best-effort: canonical request tracking should not break the cascade flow.
-      try {
-        const targetStatus = cascadeResult.allow ? "approved" : "denied";
-        resolveCanonicalGuardianRequest(candidateId, "pending", {
-          status: targetStatus,
-        });
-      } catch {
-        // Ignore — canonical request tracking is best-effort
-      }
     }
   }
 
@@ -880,11 +924,6 @@ export class Conversation {
     if (!this.processing) {
       await this.ensureActorScopedHistory();
     }
-    // One-way flag: once an attachment arrives, asset tools stay available
-    // for the remainder of the conversation.
-    if (!this.hasAttachments && attachments.length > 0) {
-      this.hasAttachments = true;
-    }
     return persistUserMessageImpl(
       this,
       content,

package/src/daemon/first-greeting.ts

@@ -0,0 +1,35 @@
+import { existsSync } from "node:fs";
+
+import { getWorkspacePromptPath } from "../util/platform.js";
+
+/**
+ * The canned assistant response for the wake-up greeting on a fresh workspace.
+ * Warm, non-presumptuous greeting that communicates "I'm new," "I improve over
+ * time," "I'm ready to be useful," and "you're in control."
+ */
+export const CANNED_FIRST_GREETING =
+  "Hey. I'm brand new, no name, no memories, nothing yet. The more we work together, the more context and memory I build, and the better I get. But let's not wait around. Throw a question at me, give me a task, or ask what I can do.";
+
+/**
+ * Returns `true` when all of the following are true:
+ * - `conversationMessageCount === 0` (no prior messages in this conversation)
+ * - BOOTSTRAP.md exists at the workspace prompt path
+ * - The trimmed content matches the macOS wake-up greeting (case-insensitive)
+ */
+export function isWakeUpGreeting(
+  content: string,
+  conversationMessageCount: number,
+): boolean {
+  if (conversationMessageCount !== 0) return false;
+  if (!existsSync(getWorkspacePromptPath("BOOTSTRAP.md"))) return false;
+  return content.trim().toLowerCase() === "wake up, my friend.";
+}
+
+/**
+ * Returns the canned first-greeting string. Simple getter that exists to keep
+ * the call site consistent and allow future flexibility (e.g., locale-aware
+ * greetings) without changing the API.
+ */
+export function getCannedFirstGreeting(): string {
+  return CANNED_FIRST_GREETING;
+}