@vellumai/assistant 0.4.34 → 0.4.36

package/src/daemon/handlers/sessions.ts

@@ -61,6 +61,23 @@ import {
 export { handleUserMessage } from "./session-user-message.js";
 import { handleUserMessage } from "./session-user-message.js";
 
+/**
+ * Extract a valid ChannelId from a binding's sourceChannel, which may carry a
+ * `notification:` namespace prefix (e.g. `"notification:telegram"` -> `"telegram"`).
+ * Returns the ChannelId if valid, or null otherwise.
+ */
+function parseBindingSourceChannel(
+  sourceChannel: string,
+): import("../../channels/types.js").ChannelId | null {
+  if (isChannelId(sourceChannel)) return sourceChannel;
+  const NOTIFICATION_PREFIX = "notification:";
+  if (sourceChannel.startsWith(NOTIFICATION_PREFIX)) {
+    const inner = sourceChannel.slice(NOTIFICATION_PREFIX.length);
+    if (isChannelId(inner)) return inner;
+  }
+  return null;
+}
+
 export function syncCanonicalStatusFromIpcConfirmationDecision(
   requestId: string,
   decision: ConfirmationResponse["decision"],
@@ -283,10 +300,12 @@ export function handleSessionList(
         updatedAt: c.updatedAt,
         threadType: normalizeThreadType(c.threadType),
         source: c.source ?? "user",
-        ...(binding && isChannelId(binding.sourceChannel)
+        ...(binding && parseBindingSourceChannel(binding.sourceChannel)
           ? {
               channelBinding: {
-                sourceChannel: binding.sourceChannel,
+                sourceChannel: parseBindingSourceChannel(
+                  binding.sourceChannel,
+                )!,
                 externalChatId: binding.externalChatId,
                 externalUserId: binding.externalUserId,
                 displayName: binding.displayName,

package/src/daemon/handlers/shared.ts

@@ -70,6 +70,14 @@ export interface HistoryToolCall {
   isError?: boolean;
   /** Base64-encoded image data from tool contentBlocks (e.g. browser_screenshot). */
   imageData?: string;
+  /** Unix ms when the tool started executing. */
+  startedAt?: number;
+  /** Unix ms when the tool completed. */
+  completedAt?: number;
+  /** Confirmation decision for this tool call: "approved" | "denied" | "timed_out". */
+  confirmationDecision?: string;
+  /** Friendly label for the confirmation (e.g. "Edit File", "Run Command"). */
+  confirmationLabel?: string;
 }
 
 export interface HistorySurface {
@@ -468,6 +476,15 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
         : {};
       const id = typeof block.id === "string" ? block.id : "";
       const entry: HistoryToolCall = { name, input };
+      // Extract persisted timing/confirmation metadata
+      if (typeof block._startedAt === "number")
+        entry.startedAt = block._startedAt;
+      if (typeof block._completedAt === "number")
+        entry.completedAt = block._completedAt;
+      if (typeof block._confirmationDecision === "string")
+        entry.confirmationDecision = block._confirmationDecision;
+      if (typeof block._confirmationLabel === "string")
+        entry.confirmationLabel = block._confirmationLabel;
       toolCalls.push(entry);
       if (id) pendingToolUses.set(id, entry);
       contentOrder.push(`tool:${toolCalls.length - 1}`);

package/src/daemon/ipc-contract/apps.ts

@@ -238,6 +238,8 @@ export interface ForkSharedAppResponse {
 export interface BundleAppResponse {
   type: "bundle_app_response";
   bundlePath: string;
+  /** Base64-encoded PNG of the generated app icon, if available. */
+  iconImageBase64?: string;
   manifest: {
     format_version: number;
     name: string;

package/src/daemon/ipc-contract/computer-use.ts

@@ -217,6 +217,14 @@ export interface WatchCompleteRequest {
   watchId: string;
 }
 
+/** Server → Client: bootstrap failure during learn-mode recording setup. */
+export interface RideShotgunError {
+  type: "ride_shotgun_error";
+  watchId: string;
+  sessionId: string;
+  message: string;
+}
+
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
 export type _ComputerUseClientMessages =
@@ -236,6 +244,7 @@ export type _ComputerUseServerMessages =
   | TaskRouted
   | RideShotgunProgress
   | RideShotgunResult
+  | RideShotgunError
   | WatchStarted
   | WatchCompleteRequest
   | RecordingStart

package/src/daemon/ipc-contract/contacts.ts

@@ -1,11 +1,11 @@
-// Contact management: list, get, and update channel status.
+// Contact management: list, get, update channel status, and delete.
 
 // === Client → Server ===
 
 export interface ContactsRequest {
   type: "contacts";
-  action: "list" | "get" | "update_channel";
-  /** Contact ID (get only). */
+  action: "list" | "get" | "update_channel" | "delete";
+  /** Contact ID (get and delete). */
   contactId?: string;
   /** Channel ID (update_channel only). */
   channelId?: string;

package/src/daemon/ipc-contract/inbox.ts

@@ -25,6 +25,8 @@ export interface ContactsInviteRequest {
   status?: string;
   /** Invitee's first name (voice invite create only). */
   friendName?: string;
+  /** Contact display name for personalizing invite instructions (create only). */
+  contactName?: string;
   /** Guardian's first name (voice invite create only). */
   guardianName?: string;
 }

package/src/daemon/ipc-contract/messages.ts

@@ -80,6 +80,8 @@ export interface ToolUseStart {
   toolName: string;
   input: Record<string, unknown>;
   sessionId?: string;
+  /** The tool_use block ID for client-side correlation. */
+  toolUseId?: string;
 }
 
 export interface ToolOutputChunk {
@@ -240,6 +242,8 @@ export interface ConfirmationStateChanged {
   causedByRequestId?: string;
   /** Normalized user text for analytics/debug (e.g. "approve", "deny"). */
   decisionText?: string;
+  /** The tool_use block ID this confirmation applies to, for disambiguating parallel tool calls. */
+  toolUseId?: string;
 }
 
 /**

package/src/daemon/ipc-contract/sessions.ts

@@ -288,6 +288,14 @@ export interface HistoryResponseToolCall {
   isError?: boolean;
   /** Base64-encoded image data from tool contentBlocks (e.g. browser_screenshot). */
   imageData?: string;
+  /** Unix ms when the tool started executing. */
+  startedAt?: number;
+  /** Unix ms when the tool completed. */
+  completedAt?: number;
+  /** Confirmation decision for this tool call: "approved" | "denied" | "timed_out". */
+  confirmationDecision?: string;
+  /** Friendly label for the confirmation (e.g. "Edit File", "Run Command"). */
+  confirmationLabel?: string;
 }
 
 export interface HistoryResponseSurface {

package/src/daemon/ipc-contract-inventory.json

@@ -278,6 +278,7 @@
     "recording_start",
     "recording_stop",
     "reminders_list_response",
+    "ride_shotgun_error",
     "ride_shotgun_progress",
     "ride_shotgun_result",
     "schedule_thread_created",

package/src/daemon/lifecycle.ts

@@ -47,7 +47,6 @@ import {
 import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { startScheduler } from "../schedule/scheduler.js";
-import { migrateKeychainToEncrypted } from "../security/keychain-to-encrypted-migration.js";
 import { getLogger, initLogger } from "../util/logger.js";
 import {
   ensureDataDir,
@@ -143,10 +142,6 @@ export async function runDaemon(): Promise<void> {
     migrateToWorkspaceLayout();
     ensureDataDir();
 
-    // Copy any existing macOS keychain secrets into the encrypted file store
-    // before config loads, so the new encrypted-store-first read path sees them.
-    migrateKeychainToEncrypted();
-
     // Load (or generate + persist) the auth signing key so tokens survive
     // daemon restarts. Must happen after ensureDataDir() creates the
     // protected directory.

package/src/daemon/ride-shotgun-handler.ts

@@ -2,6 +2,11 @@ import { randomUUID } from "node:crypto";
 import type * as net from "node:net";
 
 import { autoNavigate } from "../tools/browser/auto-navigate.js";
+import {
+  type CdpSession,
+  ensureChromeWithCdp,
+  minimizeChromeWindow,
+} from "../tools/browser/chrome-cdp.js";
 import { NetworkRecorder } from "../tools/browser/network-recorder.js";
 import type { SessionRecording } from "../tools/browser/network-recording-types.js";
 import { saveRecording } from "../tools/browser/recording-store.js";
@@ -24,6 +29,9 @@ const log = getLogger("ride-shotgun-handler");
 /** Active network recorders keyed by watchId. */
 const activeRecorders = new Map<string, NetworkRecorder>();
 
+/** Active CDP sessions keyed by watchId — tracks browser ownership for cleanup. */
+const activeCdpSessions = new Map<string, CdpSession>();
+
 /** Active progress interval timers keyed by watchId, cleared on session completion. */
 const activeProgressIntervals = new Map<string, NodeJS.Timeout>();
 
@@ -71,20 +79,48 @@ async function completeSession(session: WatchSession): Promise<void> {
 
   // In learn mode, stop recording and save — skip the LLM summary (not needed)
   if (session.isLearnMode && session.recordingId) {
-    session.savedRecordingPath = await finalizeLearnRecording(
-      watchId,
-      session,
-      session.recordingId,
-    );
-    lastSummaryBySession.set(
-      sessionId,
-      session.savedRecordingPath
+    const hasRecorder = activeRecorders.has(watchId);
+
+    if (hasRecorder) {
+      session.savedRecordingPath = await finalizeLearnRecording(
+        watchId,
+        session,
+        session.recordingId,
+      );
+    }
+
+    // Clean up the CDP session — minimize if we launched Chrome, leave it alone otherwise
+    const cdpSession = activeCdpSessions.get(watchId);
+    if (cdpSession) {
+      activeCdpSessions.delete(watchId);
+      if (cdpSession.launchedByUs) {
+        try {
+          await minimizeChromeWindow(cdpSession.baseUrl);
+          log.info({ watchId }, "Minimized assistant-launched Chrome window");
+        } catch (err) {
+          log.debug({ err, watchId }, "Failed to minimize Chrome window");
+        }
+      }
+    }
+
+    // Use bootstrapFailureReason as the primary discriminator — hasRecorder
+    // alone can't distinguish "browser never launched" from "recorder failed
+    // after retries" since both leave activeRecorders empty.
+    const summary = session.bootstrapFailureReason
+      ? `Learn session failed — ${session.bootstrapFailureReason}`
+      : session.savedRecordingPath
         ? "Learn session completed — recording saved."
-        : "Learn session completed — recording failed to save.",
-    );
+        : "Learn session completed — recording failed to save.";
+
+    lastSummaryBySession.set(sessionId, summary);
     session.status = "completed";
     log.info(
-      { watchId, sessionId },
+      {
+        watchId,
+        sessionId,
+        hasRecorder,
+        bootstrapFailureReason: session.bootstrapFailureReason,
+      },
       "Learn session complete — firing completion notifier",
     );
     fireWatchCompletionNotifier(sessionId, session);
@@ -142,10 +178,67 @@ export async function handleRideShotgunStart(
     "Session created and stored in watchSessions map",
   );
 
-  // In learn mode, connect directly to Chrome's CDP endpoint for network recording.
-  // Retry a few times since Chrome may still be starting up after the Swift client restarts it.
+  // In learn mode, ensure Chrome is available with CDP, then connect for network recording.
   if (isLearnMode) {
     const startRecording = async () => {
+      // Ensure Chrome is running with CDP — launches it if needed
+      let cdpSession: CdpSession;
+      try {
+        cdpSession = await ensureChromeWithCdp({
+          startUrl: targetDomain ? `https://${targetDomain}` : undefined,
+        });
+        // If session completed while we were awaiting Chrome, skip storing to avoid a stale map entry
+        if (session.status !== "active") {
+          log.info(
+            { watchId, status: session.status },
+            "Session no longer active after CDP launch — skipping recording",
+          );
+          // If we launched Chrome, minimize it since completeSession already ran and won't find it
+          if (cdpSession.launchedByUs) {
+            try {
+              await minimizeChromeWindow(cdpSession.baseUrl);
+              log.info(
+                { watchId },
+                "Minimized assistant-launched Chrome window (post-session)",
+              );
+            } catch (err) {
+              log.debug(
+                { err, watchId },
+                "Failed to minimize Chrome window (post-session)",
+              );
+            }
+          }
+          return;
+        }
+        activeCdpSessions.set(watchId, cdpSession);
+        log.info(
+          {
+            watchId,
+            launchedByUs: cdpSession.launchedByUs,
+            baseUrl: cdpSession.baseUrl,
+          },
+          "CDP session established",
+        );
+      } catch (err) {
+        log.warn(
+          { err, watchId },
+          "Failed to ensure Chrome with CDP — cannot start recording",
+        );
+        ctx.send(socket, {
+          type: "ride_shotgun_error",
+          watchId,
+          sessionId,
+          message:
+            "Failed to start browser — Chrome CDP could not be launched.",
+        });
+        // Fail-fast: complete the session immediately instead of waiting for timeout
+        session.bootstrapFailureReason = "browser could not be started.";
+        await completeSession(session);
+        return;
+      }
+
+      const cdpBaseUrl = cdpSession.baseUrl;
+
       for (let attempt = 0; attempt < 10; attempt++) {
         // Check if session is still active before each attempt
         if (session.status !== "active") {
@@ -156,7 +249,7 @@ export async function handleRideShotgunStart(
           return;
         }
         try {
-          const recorder = new NetworkRecorder(targetDomain);
+          const recorder = new NetworkRecorder(targetDomain, cdpBaseUrl);
           recorder.loginSignals = getLoginSignals(targetDomain);
           await recorder.startDirect();
           // If session completed while we were connecting, stop immediately to avoid leak
@@ -248,7 +341,7 @@ export async function handleRideShotgunStart(
                 clearInterval(checkInterval);
               }
             }, 1000);
-            navigateXPages(abortSignal)
+            navigateXPages({ abortSignal, cdpBaseUrl })
               .then((completed) => {
                 clearInterval(checkInterval);
                 log.info(
@@ -275,16 +368,20 @@ export async function handleRideShotgunStart(
                 clearInterval(checkInterval);
               }
             }, 1000);
-            autoNavigate(navDomain, abortSignal, (progress) => {
-              // Send progress to connected client
-              if (progress.type === "visiting" && progress.url) {
-                const shortUrl = progress.url.replace(/^https?:\/\//, "");
-                ctx.send(socket, {
-                  type: "ride_shotgun_progress",
-                  watchId,
-                  message: `[${progress.pageNumber || "?"}] ${shortUrl}`,
-                });
-              }
+            autoNavigate(navDomain, {
+              abortSignal,
+              onProgress: (progress) => {
+                // Send progress to connected client
+                if (progress.type === "visiting" && progress.url) {
+                  const shortUrl = progress.url.replace(/^https?:\/\//, "");
+                  ctx.send(socket, {
+                    type: "ride_shotgun_progress",
+                    watchId,
+                    message: `[${progress.pageNumber || "?"}] ${shortUrl}`,
+                  });
+                }
+              },
+              cdpBaseUrl,
             })
               .then((visited) => {
                 clearInterval(checkInterval);
@@ -326,6 +423,15 @@ export async function handleRideShotgunStart(
               { err, watchId },
               "Failed to start network recording after 10 attempts",
             );
+            ctx.send(socket, {
+              type: "ride_shotgun_error",
+              watchId,
+              sessionId,
+              message: "Failed to start network recording after 10 attempts.",
+            });
+            session.bootstrapFailureReason =
+              "network recording could not be started after 10 attempts.";
+            await completeSession(session);
           }
         }
       }
@@ -336,6 +442,14 @@ export async function handleRideShotgunStart(
 
   // Set timeout for duration expiry
   session.timeoutHandle = setTimeout(() => {
+    if (
+      session.isLearnMode &&
+      !activeRecorders.has(watchId) &&
+      !session.bootstrapFailureReason
+    ) {
+      session.bootstrapFailureReason =
+        "session timed out before recording could start.";
+    }
     completeSession(session);
   }, durationSeconds * 1000);
 

package/src/daemon/session-agent-loop-handlers.ts

@@ -67,6 +67,22 @@ export interface EventHandlerState {
   firstThinkingDeltaEmitted: boolean;
   /** Name of the last completed tool, used to generate contextual statusText. */
   lastCompletedToolName: string | undefined;
+  /** Tracks tool_use_id → timing data for persisting on content blocks. */
+  readonly toolCallTimestamps: Map<
+    string,
+    { startedAt: number; completedAt?: number }
+  >;
+  /** The tool_use_id of the currently executing tool (set in handleToolUse, cleared in handleToolResult). */
+  currentToolUseId: string | undefined;
+  /** Maps confirmation requestId → tool_use_id for linking decisions to tools. */
+  readonly requestIdToToolUseId: Map<string, string>;
+  /** Stores confirmation outcomes keyed by tool_use_id. */
+  readonly toolConfirmationOutcomes: Map<
+    string,
+    { decision: string; label: string }
+  >;
+  /** tool_use_ids emitted in the current turn (populated in handleToolUse, cleared after annotation). */
+  currentTurnToolUseIds: string[];
 }
 
 /** Immutable context shared across event handlers within a single agent loop run. */
@@ -108,6 +124,11 @@ export function createEventHandlerState(): EventHandlerState {
     firstTextDeltaEmitted: false,
     firstThinkingDeltaEmitted: false,
     lastCompletedToolName: undefined,
+    toolCallTimestamps: new Map(),
+    currentToolUseId: undefined,
+    requestIdToToolUseId: new Map(),
+    toolConfirmationOutcomes: new Map(),
+    currentTurnToolUseIds: [],
   };
 }
 
@@ -253,6 +274,9 @@ export function handleToolUse(
 ): void {
   state.toolUseIdToName.set(event.id, event.name);
   state.currentTurnToolNames.push(event.name);
+  state.toolCallTimestamps.set(event.id, { startedAt: Date.now() });
+  state.currentToolUseId = event.id;
+  state.currentTurnToolUseIds.push(event.id);
   const statusText = `Running ${friendlyToolName(event.name)}`;
   deps.ctx.emitActivityState(
     "tool_running",
@@ -266,6 +290,7 @@ export function handleToolUse(
     toolName: event.name,
     input: event.input,
     sessionId: deps.ctx.conversationId,
+    toolUseId: event.id,
   });
 }
 
@@ -392,6 +417,11 @@ export function handleToolResult(
     contentBlocks: event.contentBlocks,
   });
 
+  // Record tool completion timestamp
+  const ts = state.toolCallTimestamps.get(event.toolUseId);
+  if (ts) ts.completedAt = Date.now();
+  state.currentToolUseId = undefined;
+
   const toolName = state.toolUseIdToName.get(event.toolUseId);
   if (toolName === "file_write" || toolName === "bash") {
     deps.ctx.markWorkspaceTopLevelDirty();
@@ -433,6 +463,68 @@ export function handleToolResult(
     deps.reqId,
     statusText,
   );
+
+  // Once all tools for this turn have completed, annotate the persisted
+  // assistant message with timing and confirmation metadata.
+  const allToolsDone = state.currentTurnToolUseIds.every((id) => {
+    const ts = state.toolCallTimestamps.get(id);
+    return ts && ts.completedAt != null;
+  });
+  if (allToolsDone && state.currentTurnToolUseIds.length > 0) {
+    annotatePersistedAssistantMessage(state);
+  }
+}
+
+/**
+ * After all tools for the current turn complete, fetch the persisted assistant
+ * message, annotate its tool_use blocks with timing and confirmation metadata,
+ * and update the DB. This runs post-tool-execution so the metadata maps are
+ * fully populated (unlike message_complete which fires before tools run).
+ */
+function annotatePersistedAssistantMessage(state: EventHandlerState): void {
+  const messageId = state.lastAssistantMessageId;
+  if (!messageId) return;
+
+  const row = conversationStore.getMessageById(messageId);
+  if (!row) return;
+
+  let content: ContentBlock[];
+  try {
+    content = JSON.parse(row.content) as ContentBlock[];
+  } catch {
+    return;
+  }
+
+  let modified = false;
+  for (const block of content) {
+    if (block.type === "tool_use") {
+      const rec = block as unknown as Record<string, unknown>;
+      const id = rec.id as string | undefined;
+      if (!id) continue;
+
+      const ts = state.toolCallTimestamps.get(id);
+      if (ts) {
+        rec._startedAt = ts.startedAt;
+        if (ts.completedAt != null) {
+          rec._completedAt = ts.completedAt;
+        }
+        modified = true;
+      }
+      const confirmation = state.toolConfirmationOutcomes.get(id);
+      if (confirmation) {
+        rec._confirmationDecision = confirmation.decision;
+        rec._confirmationLabel = confirmation.label;
+        modified = true;
+      }
+    }
+  }
+
+  if (modified) {
+    conversationStore.updateMessageContent(messageId, JSON.stringify(content));
+  }
+
+  // Clear for the next turn
+  state.currentTurnToolUseIds = [];
 }
 
 export function handleError(
@@ -465,6 +557,9 @@ export async function handleMessageComplete(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: "message_complete" }>,
 ): Promise<void> {
+  // Reset per-turn tool tracking for the new turn.
+  state.currentTurnToolUseIds = [];
+
   // Flush any remaining directive display buffer
   if (state.pendingDirectiveDisplayBuffer.length > 0) {
     deps.onEvent({
@@ -533,6 +628,11 @@ export async function handleMessageComplete(
     );
   }
 
+  // NOTE: Tool timing/confirmation annotations are NOT applied here because
+  // message_complete fires BEFORE tool_use/tool_result events. The annotations
+  // are applied in handleToolResult after all tools for the turn complete,
+  // then the persisted message is updated via updateMessageContent.
+
   // Build content with UI surfaces
   const contentWithSurfaces: ContentBlock[] = [...cleanedBlocks];
   for (const surface of deps.ctx.currentTurnSurfaces) {

package/src/daemon/session-agent-loop.ts

@@ -118,6 +118,27 @@ import type { TraceEmitter } from "./trace-emitter.js";
 
 const log = getLogger("session-agent-loop");
 
+/** Title-cased friendly labels for tool names, used in confirmation chips. */
+const TOOL_FRIENDLY_LABEL: Record<string, string> = {
+  bash: "Run Command",
+  web_search: "Web Search",
+  web_fetch: "Web Fetch",
+  file_read: "Read File",
+  file_write: "Write File",
+  file_edit: "Edit File",
+  browser_navigate: "Browser",
+  browser_click: "Browser",
+  browser_type: "Browser",
+  browser_screenshot: "Browser",
+  browser_scroll: "Browser",
+  browser_wait: "Browser",
+  app_create: "Create App",
+  app_update: "Update App",
+  skill_load: "Load Skill",
+  app_file_edit: "Edit App File",
+  app_file_write: "Write App File",
+};
+
 type GitServiceInitializer = {
   ensureInitialized(): Promise<void>;
 };
@@ -222,6 +243,18 @@ export interface AgentLoopSessionContext {
       : never,
   ): void;
 
+  /**
+   * Optional callback invoked by the Session when a confirmation state changes.
+   * The agent loop registers this to track requestId → toolUseId mappings
+   * and record confirmation outcomes for persistence.
+   */
+  onConfirmationOutcome?: (
+    requestId: string,
+    state: string,
+    toolName?: string,
+    toolUseId?: string,
+  ) => void;
+
   getWorkspaceGitService?: (workspaceDir: string) => GitServiceInitializer;
   commitTurnChanges?: typeof commitTurnChanges;
 
@@ -432,6 +465,44 @@ export async function runAgentLoopImpl(
     }
 
     const state = createEventHandlerState();
+
+    // Register confirmation outcome tracker so the agent loop can link
+    // confirmation decisions to tool_use_ids for persistence.
+    ctx.onConfirmationOutcome = (
+      requestId,
+      confirmationState,
+      toolName,
+      toolUseId,
+    ) => {
+      if (confirmationState === "pending") {
+        // Use the toolUseId passed from the prompter (which knows which tool
+        // requested confirmation) instead of the ambient state.currentToolUseId,
+        // which is unreliable when multiple tools execute in parallel.
+        const resolvedToolUseId = toolUseId ?? state.currentToolUseId;
+        if (resolvedToolUseId) {
+          state.requestIdToToolUseId.set(requestId, resolvedToolUseId);
+        }
+      } else if (
+        confirmationState === "approved" ||
+        confirmationState === "denied" ||
+        confirmationState === "timed_out"
+      ) {
+        const resolvedId =
+          state.requestIdToToolUseId.get(requestId) ?? toolUseId;
+        if (resolvedId) {
+          const name = state.toolUseIdToName.get(resolvedId) ?? toolName ?? "";
+          // Build a friendly label from the tool name
+          const label =
+            TOOL_FRIENDLY_LABEL[name] ??
+            name.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+          state.toolConfirmationOutcomes.set(resolvedId, {
+            decision: confirmationState,
+            label,
+          });
+        }
+      }
+    };
+
     let runMessages = ctx.messages;
 
     const memoryResult = await prepareMemoryContext(
@@ -1347,6 +1418,7 @@ export async function runAgentLoopImpl(
 
     ctx.abortController = null;
     ctx.processing = false;
+    ctx.onConfirmationOutcome = undefined;
     ctx.surfaceActionRequestIds.delete(ctx.currentRequestId ?? "");
     ctx.currentRequestId = undefined;
     ctx.currentActiveSurfaceId = undefined;