@vellumai/assistant 0.12.2 → 0.12.3-staging.1

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

@@ -12,6 +12,7 @@ import { v4 as uuid } from "uuid";
 
 import { onActivationToolCall } from "../activation/turn-hooks.js";
 import type { AgentEvent } from "../agent/loop.js";
+import { resolveComputerUseToolName } from "../api/computer-use-tool.js";
 import type { AnsweredQuestion } from "../api/events/question-answered.js";
 import type { AssistantEvent } from "../api/index.js";
 import type {
@@ -321,6 +322,8 @@ export interface EventHandlerState {
   providerErrorProfile: string | null;
   persistProviderErrorAsAssistantMessage: boolean;
   lastAssistantMessageId: string | undefined;
+  /** Assistant rows that must join the turn's final disk-view export. */
+  readonly assistantMessageIdsToSync: Set<string>;
   /**
    * Visibility marker stamped on {@link lastAssistantMessageId}, when the turn
    * routed its reply through `send_user_message`. The turn's terminal
@@ -365,6 +368,12 @@ export interface EventHandlerState {
   readonly accumulatedToolContentBlocks: ContentBlock[];
   /** Maps index in accumulatedToolContentBlocks → tool name that produced it. */
   readonly toolContentBlockToolNames: Map<number, string>;
+  /** Supported computer-use calls in model invocation order for this run. */
+  readonly computerUseToolUseIds: string[];
+  /** Tool names for supported computer-use ids, also used for persisted names. */
+  readonly computerUseToolNames: Map<string, string>;
+  /** Latest screenshot block for each supported invocation. */
+  readonly computerUseScreenshotBlocks: Map<string, ImageContent>;
   readonly directiveWarnings: string[];
   readonly toolUseIdToName: Map<string, string>;
   /** Sticky for the whole run: this turn created/refreshed an app. */
@@ -707,6 +716,7 @@ export function createEventHandlerState(): EventHandlerState {
     providerErrorProfile: null,
     persistProviderErrorAsAssistantMessage: false,
     lastAssistantMessageId: undefined,
+    assistantMessageIdsToSync: new Set(),
     assistantRowAwaitingFinalization: false,
     inflightWriters: new Map(),
     pendingToolResults: new Map(),
@@ -715,6 +725,9 @@ export function createEventHandlerState(): EventHandlerState {
     accumulatedDirectives: [],
     accumulatedToolContentBlocks: [],
     toolContentBlockToolNames: new Map(),
+    computerUseToolUseIds: [],
+    computerUseToolNames: new Map(),
+    computerUseScreenshotBlocks: new Map(),
     directiveWarnings: [],
     toolUseIdToName: new Map(),
     appBuildToolUsedThisRun: false,
@@ -759,6 +772,26 @@ export function createEventHandlerState(): EventHandlerState {
   };
 }
 
+/** Select the last screenshot-bearing computer-use call by invocation order. */
+export function selectFinalComputerUseScreenshotCandidate(
+  state: Pick<
+    EventHandlerState,
+    | "computerUseToolUseIds"
+    | "computerUseToolNames"
+    | "computerUseScreenshotBlocks"
+  >,
+): { toolName: string; block: ImageContent } | undefined {
+  for (let i = state.computerUseToolUseIds.length - 1; i >= 0; i--) {
+    const toolUseId = state.computerUseToolUseIds[i]!;
+    const block = state.computerUseScreenshotBlocks.get(toolUseId);
+    const toolName = state.computerUseToolNames.get(toolUseId);
+    if (block && toolName) {
+      return { toolName, block };
+    }
+  }
+  return undefined;
+}
+
 /**
  * Resolve this turn's reveal candidates for chat sentinel redaction.
  *
@@ -1761,6 +1794,14 @@ export function handleToolUse(
   event: Extract<AgentEvent, { type: "tool_use" }>,
 ): void {
   state.toolUseIdToName.set(event.id, event.name);
+  const computerUseToolName = resolveComputerUseToolName(
+    event.name,
+    event.input,
+  );
+  if (computerUseToolName) {
+    state.computerUseToolUseIds.push(event.id);
+    state.computerUseToolNames.set(event.id, computerUseToolName);
+  }
   // Activation checklist: keep the launched task's live step count moving.
   // Fire-and-forget and throttled inside the hook; a no-op for every
   // conversation no activation task points at.
@@ -2233,16 +2274,41 @@ export async function finalizePendingToolResultRow(
     state.pendingToolResults,
     await resolvedRevealCandidatesForState(state),
   );
-  const contentJson = JSON.stringify(
+  const referencedBlocks =
     conv != null
       ? await referenceMediaBlocksForPersist(
           conversationId,
           conv.createdAt,
           rowId,
           blocks as ContentBlock[],
+          state.computerUseToolNames,
         )
-      : blocks,
-  );
+      : blocks;
+  for (const block of referencedBlocks) {
+    // guard:allow-tool-result-only: locally-executed tool results carry rich
+    // contentBlocks and pending computer-use state; provider web-search
+    // results carry opaque content and never enter the local pending-tool map.
+    if (block.type !== "tool_result") {
+      continue;
+    }
+    const pending = state.pendingToolResults.get(block.tool_use_id);
+    if (pending && block.contentBlocks) {
+      pending.contentBlocks = block.contentBlocks;
+    }
+    if (!state.computerUseToolNames.has(block.tool_use_id)) {
+      continue;
+    }
+    const screenshot = block.contentBlocks
+      ?.filter(
+        (contentBlock): contentBlock is ImageContent =>
+          contentBlock.type === "image",
+      )
+      .at(-1);
+    if (screenshot) {
+      state.computerUseScreenshotBlocks.set(block.tool_use_id, screenshot);
+    }
+  }
+  const contentJson = JSON.stringify(referencedBlocks);
   const toolRowFinalized = await finalizeInflightContent(
     state.inflightWriters.get(rowId),
     rowId,
@@ -2528,8 +2594,13 @@ export async function handleToolResult(
     deps.ctx.markWorkspaceTopLevelDirty();
   }
 
+  const computerUseCall = state.computerUseToolNames.has(event.toolUseId);
   if (event.contentBlocks) {
     for (const cb of event.contentBlocks) {
+      if (computerUseCall && cb.type === "image") {
+        state.computerUseScreenshotBlocks.set(event.toolUseId, cb);
+        continue;
+      }
       if (cb.type === "image" || cb.type === "file") {
         state.accumulatedToolContentBlocks.push(cb);
         if (toolName) {

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

@@ -38,6 +38,7 @@ import {
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { isSendUserMessageActiveForTurn } from "../config/send-user-message-gate.js";
+import { desktopAutomationLease } from "../desktop/desktop-automation-lease.js";
 import { writeRelationshipState } from "../home/relationship-state-writer.js";
 import type { UserPromptSubmitInputContext } from "../hooks/types.js";
 import {
@@ -105,6 +106,7 @@ import {
   type EventHandlerDeps,
   finalizePendingToolResultRow,
   resetInjectionLedgersForStrip,
+  selectFinalComputerUseScreenshotCandidate,
   settlePendingPartialFlush,
 } from "./conversation-agent-loop-handlers.js";
 import {
@@ -913,6 +915,7 @@ export async function runAgentLoopImpl(
     if (ctx.pendingReactionRecords?.length) {
       ownedReactionRecords.push(...ctx.pendingReactionRecords.splice(0));
     }
+    desktopAutomationLease.releaseForConversation(ctx.conversationId);
     ctx.abortController = null;
     ctx.setProcessing(false);
     unregisterInflightTurn(ctx.conversationId, state);
@@ -1949,6 +1952,8 @@ export async function runAgentLoopImpl(
               state.lastAssistantMessageId,
             )
           : state.lastAssistantMessageId;
+      const computerUseScreenshotCandidate =
+        selectFinalComputerUseScreenshotCandidate(state);
       // Resolve attachments (only when not cancelled, this is expensive async I/O)
       const attachmentResult = await resolveAssistantAttachments(
         state.accumulatedDirectives,
@@ -1965,9 +1970,16 @@ export async function runAgentLoopImpl(
           ),
         attachmentTargetMessageId,
         state.toolContentBlockToolNames,
+        computerUseScreenshotCandidate,
       );
       const { assistantAttachments, emittedAttachments } = attachmentResult;
       persistedAttachmentFiles = attachmentResult.persistedFiles;
+      if (
+        attachmentTargetMessageId &&
+        attachmentResult.linkedAttachmentIds.length > 0
+      ) {
+        state.assistantMessageIdsToSync.add(attachmentTargetMessageId);
+      }
 
       ctx.lastAssistantAttachments = assistantAttachments;
       ctx.lastAttachmentWarnings = attachmentResult.directiveWarnings;

package/src/daemon/conversation-attachments.ts

@@ -2,10 +2,14 @@ import type { PermissionPrompter } from "../permissions/prompter.js";
 import {
   attachInlineAttachmentToMessage,
   AttachmentUploadError,
+  getAttachmentsByIds,
   getFilePathForAttachment,
+  linkAttachmentToMessage,
   setAttachmentThumbnail,
 } from "../persistence/attachments-store.js";
-import type { ContentBlock } from "../providers/types.js";
+import { updateMessageMetadata } from "../persistence/conversation-crud.js";
+import { COMPUTER_USE_SCREENSHOT_ATTACHMENT_IDS_KEY } from "../persistence/conversation-types.js";
+import type { ContentBlock, ImageContent } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 import {
   type ApproveHostRead,
@@ -14,7 +18,9 @@ import {
   contentBlocksToDrafts,
   deduplicateDrafts,
   type DirectiveRequest,
+  estimateBase64Bytes,
   resolveDirectives,
+  toolImageFilename,
   validateDrafts,
 } from "./assistant-attachments.js";
 import type { UserMessageAttachment } from "./message-protocol.js";
@@ -88,6 +94,19 @@ export interface AttachmentResolutionResult {
   emittedAttachments: UserMessageAttachment[];
   directiveWarnings: string[];
   persistedFiles: PersistedAttachmentFile[];
+  /** Attachment ids successfully linked to the target assistant row. */
+  linkedAttachmentIds: string[];
+  computerUseScreenshotAttachmentIds: string[];
+}
+
+export interface ComputerUseScreenshotCandidate {
+  toolName: string;
+  block: ImageContent;
+}
+
+interface ResolvedAttachmentDraft extends AssistantAttachmentDraft {
+  existingAttachmentId?: string;
+  computerUseScreenshot?: boolean;
 }
 
 /**
@@ -102,10 +121,13 @@ export async function resolveAssistantAttachments(
   approveHostRead: ApproveHostRead,
   lastAssistantMessageId: string | undefined,
   toolContentBlockToolNames?: ReadonlyMap<number, string>,
+  computerUseScreenshotCandidate?: ComputerUseScreenshotCandidate,
 ): Promise<AttachmentResolutionResult> {
-  let assistantAttachments: AssistantAttachmentDraft[] = [];
+  let assistantAttachments: ResolvedAttachmentDraft[] = [];
   const emittedAttachments: UserMessageAttachment[] = [];
   const persistedFiles: PersistedAttachmentFile[] = [];
+  const linkedAttachmentIds: string[] = [];
+  const computerUseScreenshotAttachmentIds: string[] = [];
 
   const recordPersistedFile = (draft: AssistantAttachmentDraft): void => {
     if (draft.sourcePath) {
@@ -128,7 +150,8 @@ export async function resolveAssistantAttachments(
 
   if (
     accumulatedDirectives.length > 0 ||
-    accumulatedToolContentBlocks.length > 0
+    accumulatedToolContentBlocks.length > 0 ||
+    computerUseScreenshotCandidate !== undefined
   ) {
     const directiveDrafts =
       accumulatedDirectives.length > 0
@@ -159,10 +182,42 @@ export async function resolveAssistantAttachments(
       "Directive resolution complete",
     );
 
-    const toolDrafts = contentBlocksToDrafts(
+    const toolDrafts: ResolvedAttachmentDraft[] = contentBlocksToDrafts(
       accumulatedToolContentBlocks,
       toolContentBlockToolNames,
     );
+    if (computerUseScreenshotCandidate) {
+      const { block, toolName } = computerUseScreenshotCandidate;
+      const filename =
+        block.source.filename ??
+        toolImageFilename(block.source.media_type, toolName);
+      if (block.source.type === "workspace_ref") {
+        const stored = getAttachmentsByIds([block.source.attachmentId], {
+          hydrateFileData: true,
+        })[0];
+        if (stored?.dataBase64) {
+          toolDrafts.push({
+            sourceType: "tool_block",
+            filename,
+            mimeType: stored.mimeType,
+            dataBase64: stored.dataBase64,
+            sizeBytes: stored.sizeBytes,
+            kind: "image",
+            existingAttachmentId: stored.id,
+            computerUseScreenshot: true,
+          });
+        }
+      } else {
+        toolDrafts.push({
+          sourceType: "tool_block",
+          filename,
+          mimeType: block.source.media_type,
+          dataBase64: block.source.data,
+          sizeBytes: estimateBase64Bytes(block.source.data),
+          kind: "image",
+        });
+      }
+    }
     // Most recent tool outputs first so deduplication keeps the latest version.
     toolDrafts.reverse();
     const merged = deduplicateDrafts([
@@ -195,14 +250,27 @@ export async function resolveAssistantAttachments(
       const draft = assistantAttachments[i];
       let stored;
       try {
-        stored = await attachInlineAttachmentToMessage(
-          lastAssistantMessageId,
-          i,
-          draft.filename,
-          draft.mimeType,
-          draft.dataBase64,
-          { skipSizeLimit: true },
-        );
+        stored = draft.existingAttachmentId
+          ? getAttachmentsByIds([
+              linkAttachmentToMessage(
+                lastAssistantMessageId,
+                draft.existingAttachmentId,
+                i,
+              ),
+            ])[0]
+          : await attachInlineAttachmentToMessage(
+              lastAssistantMessageId,
+              i,
+              draft.filename,
+              draft.mimeType,
+              draft.dataBase64,
+              { skipSizeLimit: true },
+            );
+        if (!stored) {
+          throw new Error(
+            `Attachment not found: ${draft.existingAttachmentId}`,
+          );
+        }
       } catch (err) {
         if (err instanceof AttachmentUploadError) {
           log.warn(
@@ -241,6 +309,7 @@ export async function resolveAssistantAttachments(
       }
 
       recordPersistedFile(draft);
+      linkedAttachmentIds.push(stored.id);
       emittedAttachments.push({
         id: stored.id,
         filename: draft.filename,
@@ -250,6 +319,16 @@ export async function resolveAssistantAttachments(
         ...(omitData ? { sizeBytes: draft.sizeBytes } : {}),
         fileBacked: true,
         ...(thumbnailData ? { thumbnailData } : {}),
+        ...(draft.computerUseScreenshot ? { computerUseScreenshot: true } : {}),
+      });
+      if (draft.computerUseScreenshot) {
+        computerUseScreenshotAttachmentIds.push(stored.id);
+      }
+    }
+    if (computerUseScreenshotAttachmentIds.length > 0) {
+      updateMessageMetadata(lastAssistantMessageId, {
+        [COMPUTER_USE_SCREENSHOT_ATTACHMENT_IDS_KEY]:
+          computerUseScreenshotAttachmentIds,
       });
     }
   } else if (assistantAttachments.length > 0) {
@@ -271,5 +350,7 @@ export async function resolveAssistantAttachments(
     emittedAttachments,
     directiveWarnings,
     persistedFiles,
+    linkedAttachmentIds,
+    computerUseScreenshotAttachmentIds,
   };
 }

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

@@ -22,6 +22,11 @@ import {
 import { supportsChannelReaction } from "../messaging/providers/index.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
+import {
+  type ConversationToolSurface,
+  hashConversationToolSurface,
+  recordConversationToolSurface,
+} from "../persistence/conversation-tool-surface.js";
 import { getBindingByConversation } from "../persistence/external-conversation-store.js";
 import { getAllDefaultPluginNames } from "../plugins/defaults/main.js";
 import { isActivationSession } from "../plugins/defaults/memory/activation-session-store.js";
@@ -932,8 +937,12 @@ export function canSpawnSubagentsForTurn(ctx: Conversation): boolean {
   // executor instead. That is the right answer to "is this tool on the wire"
   // and the wrong one to "could this turn actually spawn": the memory
   // retrospective wake runs in execution mode with an allowlist that names
-  // `skill_load` but neither the dispatcher nor the spawn tool, so the spawn
-  // is denied after the prompt has already told the model to delegate.
+  // `skill_load` but neither the dispatcher nor the spawn tool, so a spawn is
+  // denied at execution. A wake replaying its source's recorded surface
+  // renders the source's delegation state in place of this answer
+  // (`Conversation.delegateIndependentTasksReplay`): a denied spawn attempt
+  // costs one tool error, a system prompt that differs from the source's
+  // costs the whole cached prefix behind it.
   const allowlist = ctx.subagentAllowedTools;
   return SUBAGENT_SPAWN_PATH_TOOL_NAMES.every(
     (name) =>
@@ -943,6 +952,57 @@ export function canSpawnSubagentsForTurn(ctx: Conversation): boolean {
   );
 }
 
+/**
+ * Build the agent loop's `onToolsSent` observer for a conversation: record
+ * the tool array each provider call sends, with the delegation-section state
+ * the prompt build captured for the prompt that call carries
+ * (`Conversation.renderedDelegateIndependentTasks`), so a later fork wake can
+ * replay both (`recordConversationToolSurface`). Only the loop's send boundary sees the
+ * sent array. The resolver is also consulted out of band (the token count
+ * behind `/compact` and `/clean`, compaction estimates), where a read outside
+ * any turn resolves a clientless surface that would overwrite the one the
+ * conversation's turns actually send.
+ *
+ * Arrays that are not the conversation's own surface are skipped: a replaying
+ * wake sends its source's array, an empty array is a tools-disabled call (a
+ * fork replaying it could never call `remember`), and disk-pressure cleanup
+ * mode narrows the wire to cleanup tools. Best-effort: a failed write is
+ * logged and the surface still counts as recorded, so a persistent failure
+ * logs once per distinct surface rather than once per provider call.
+ */
+export function createWireToolSurfaceRecorder(
+  ctx: Conversation,
+): (tools: ToolDefinition[]) => void {
+  return (tools) => {
+    if (
+      !ctx.conversationId ||
+      ctx.wireToolReplay ||
+      tools.length === 0 ||
+      ctx.diskPressureCleanupModeActive === true
+    ) {
+      return;
+    }
+    const surface: ConversationToolSurface = {
+      tools,
+      // Unknown before the first prompt build or for a verbatim override.
+      delegateIndependentTasks: ctx.renderedDelegateIndependentTasks ?? null,
+    };
+    try {
+      ctx.recordedToolSurfaceHash = recordConversationToolSurface(
+        ctx.conversationId,
+        surface,
+        ctx.recordedToolSurfaceHash,
+      );
+    } catch (err) {
+      log.warn(
+        { err, conversationId: ctx.conversationId },
+        "failed to record the conversation's wire tool surface; continuing",
+      );
+      ctx.recordedToolSurfaceHash = hashConversationToolSurface(surface);
+    }
+  };
+}
+
 /**
  * Build a resolveTools callback that merges base tool definitions with
  * dynamically projected skill tools on each agent turn. Also updates
@@ -1237,6 +1297,14 @@ export function createResolveToolsCallback(
 
     ctx.allowedToolNames = turnAllowed;
 
-    return applyActivityField(allBaseDefs);
+    // A wake replaying its source's recorded surface sends that array
+    // verbatim: the wire tool block is the first tier of the provider cache
+    // prefix (tools → system → messages), so only the same bytes read the
+    // source's cached prefix instead of rewriting it. Execution is unaffected:
+    // `allowedToolNames` above and the executor's allowlist gate still decide
+    // what may run.
+    return ctx.wireToolReplay
+      ? [...ctx.wireToolReplay]
+      : applyActivityField(allBaseDefs);
   };
 }

package/src/daemon/conversation-turn-finalize.ts

@@ -63,6 +63,8 @@ interface TurnTailContext {
 /** Minimal per-run handler state {@link settleTurnContent} consumes. */
 interface TurnContentState {
   readonly lastAssistantMessageId: string | undefined;
+  /** Earlier reply rows that must join the final disk-view export. */
+  readonly assistantMessageIdsToSync: ReadonlySet<string>;
   /** In-flight content writers the turn left behind (see EventHandlerState). */
   readonly inflightWriters: Map<string, InflightContentWriter>;
 }
@@ -224,20 +226,31 @@ export async function settleTurnContent(params: {
     );
   }
 
-  // Mirror the final assistant row into the JSONL disk view. Guarded like the
-  // steps above: this runs AFTER the terminal SSE, so a throw here must not
-  // escape into the loop's outer catch and emit a second, contradictory
-  // terminal event for a turn the client already saw complete.
-  try {
-    if (state.lastAssistantMessageId && liveConversation) {
-      syncMessageToDisk(
-        ctx.conversationId,
-        state.lastAssistantMessageId,
-        liveConversation.createdAt,
-      );
+  // Mirror every assistant row finalized by this turn into the JSONL disk
+  // view. Most turns contribute only their last row. A turn that delivered its
+  // reply through `send_user_message` can also contribute an earlier row that
+  // received the reply attachment. Set insertion order preserves the reply's
+  // position, while adding the last row deduplicates the ordinary case where
+  // both ids are the same.
+  if (liveConversation) {
+    const messageIds = new Set(state.assistantMessageIdsToSync);
+    if (state.lastAssistantMessageId) {
+      messageIds.add(state.lastAssistantMessageId);
+    }
+    for (const messageId of messageIds) {
+      try {
+        syncMessageToDisk(
+          ctx.conversationId,
+          messageId,
+          liveConversation.createdAt,
+        );
+      } catch (err) {
+        rlog.warn(
+          { err, messageId },
+          "Failed to sync assistant message to disk (non-fatal)",
+        );
+      }
     }
-  } catch (err) {
-    rlog.warn({ err }, "Failed to sync assistant message to disk (non-fatal)");
   }
 }
 

package/src/daemon/conversation.ts

@@ -92,6 +92,7 @@ import {
   markV3LiveBlock,
   MEMORY_V3_POINTER_BLOCK_METADATA_KEY,
 } from "../plugins/defaults/memory/v3/types.js";
+import { resolveDelegateIndependentTasks } from "../prompts/delegation-gate.js";
 import {
   applyBootstrapTemplate,
   buildSystemPrompt,
@@ -181,6 +182,7 @@ import {
   canSpawnSubagentsForTurn,
   createResolveToolsCallback,
   createToolExecutor,
+  createWireToolSurfaceRecorder,
 } from "./conversation-tool-setup.js";
 import { canonicalizeTimeZone } from "./date-context.js";
 import { HostAppControlProxy } from "./host-app-control-proxy.js";
@@ -452,6 +454,41 @@ export class Conversation {
    * @internal
    */
   toolContextPin?: WakeToolContextPin;
+  /**
+   * Tool definitions sent verbatim in place of the resolved wire array, for
+   * a wake replaying its source conversation's recorded surface
+   * (`recordConversationToolSurface`). Set and restored alongside the
+   * allowlist by `scopeWakeAllowedTools`; read only where the resolver returns
+   * the wire array, so it never widens what may execute.
+   * @internal
+   */
+  wireToolReplay?: readonly ToolDefinition[];
+  /**
+   * The delegation section's rendered state a wake replaying its source's
+   * recorded surface carries into its system prompt, in place of the answer
+   * derived from the wake's own scope (`canSpawnSubagentsForTurn`). Set and
+   * restored alongside {@link wireToolReplay} by `scopeWakeAllowedTools`;
+   * read only by {@link buildCurrentSystemPrompt}, so it never widens what
+   * may execute.
+   * @internal
+   */
+  delegateIndependentTasksReplay?: boolean;
+  /**
+   * The delegation-section state the system prompt most recently built by
+   * {@link buildCurrentSystemPrompt} rendered: the value the loop's prompt
+   * carries until the next build. `null` when that prompt is a verbatim
+   * override, unset before the first build. Read by the wire-surface recorder
+   * so the recorded state is the one the provider received, not a
+   * re-derivation that a config change mid-turn could flip.
+   * @internal
+   */
+  renderedDelegateIndependentTasks?: boolean | null;
+  /**
+   * Hash of the wire surface last recorded for this conversation in this
+   * process, so an unchanged surface is not rewritten on every provider call.
+   * @internal
+   */
+  recordedToolSurfaceHash?: string;
   /** @internal */ readonly skillProjectionState = new Map<string, string>();
   /** @internal */ readonly skillProjectionCache: SkillProjectionCache = {};
   /** @internal */ usageStats: UsageStats = {
@@ -1038,6 +1075,7 @@ export class Conversation {
       tools: toolDefs.length > 0 ? toolDefs : undefined,
       toolExecutor: toolDefs.length > 0 ? toolExecutor : undefined,
       resolveTools,
+      onToolsSent: createWireToolSurfaceRecorder(this),
       resolveConversationDir: () => {
         const conv = getConversation(this.conversationId);
         if (!conv) {
@@ -1132,23 +1170,40 @@ export class Conversation {
    * the provider's prefix cache).
    */
   buildCurrentSystemPrompt(): string {
-    return this.hasSystemPromptOverride
-      ? this.systemPrompt
-      : buildSystemPrompt({
-          hasNoClient: this.hasNoClient,
-          trustContext: this.currentTurnTrustContext,
-          channelCapabilities: this.currentTurnChannelCapabilities,
-          personaOverride: this.wakePersonaOverride,
-          onboardingContext: this.getOnboardingContext(),
-          conversationId: this.conversationId,
-          sendUserMessageTool: resolveSendUserMessageActive(this),
-          // Read off this turn's resolved tool surface: a workspace
-          // `tools.exclude` entry, a background run's `allowedTools` scope, a
-          // read-only subagent pass, or tools disabled all answer no, and the
-          // delegation section renders off rather than pointing at a tool the
-          // turn cannot call.
-          canSpawnSubagents: canSpawnSubagentsForTurn(this),
-        });
+    if (this.hasSystemPromptOverride) {
+      this.renderedDelegateIndependentTasks = null;
+      return this.systemPrompt;
+    }
+    // Resolved once here, handed to the builder, and kept for the
+    // wire-surface recorder, so the prompt the provider receives and the state
+    // a fork replays are the same value by construction. A wake replaying its
+    // source's recorded surface renders the section the source's live turn
+    // rendered; otherwise the answer is read off this turn's resolved tool
+    // surface: a workspace `tools.exclude` entry, a background run's
+    // `allowedTools` scope, a read-only subagent pass, or tools disabled all
+    // answer no, and the section renders off rather than pointing at a tool
+    // the turn cannot call.
+    const delegateIndependentTasks =
+      this.delegateIndependentTasksReplay ??
+      resolveDelegateIndependentTasks({
+        canSpawnSubagents: canSpawnSubagentsForTurn(this),
+        channelCapabilities: this.currentTurnChannelCapabilities,
+      });
+    const prompt = buildSystemPrompt({
+      hasNoClient: this.hasNoClient,
+      trustContext: this.currentTurnTrustContext,
+      channelCapabilities: this.currentTurnChannelCapabilities,
+      personaOverride: this.wakePersonaOverride,
+      onboardingContext: this.getOnboardingContext(),
+      conversationId: this.conversationId,
+      sendUserMessageTool: resolveSendUserMessageActive(this),
+      delegateIndependentTasks,
+    });
+    // Recorded only once the build succeeds: a wake's prompt sync swallows a
+    // failed rebuild and runs on the previous prompt, whose state must stay
+    // the recorded one.
+    this.renderedDelegateIndependentTasks = delegateIndependentTasks;
+    return prompt;
   }
 
   /**