@stigmer/runner 3.11.0 → 3.12.0

package/dist/activities/execute-cursor/index.d.ts

@@ -27,7 +27,7 @@
  */
 import { InteractionMode, ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { Config } from "../../config.js";
-import type { AgentResolution } from "./session-lifecycle.js";
+import type { AgentResolution, AgentResolutionReason } from "./session-lifecycle.js";
 import { type ExecuteActivityInput } from "../../shared/activity-input.js";
 /**
  * Creates the activity functions bound to the runner config.
@@ -42,8 +42,6 @@ export interface BuildPromptInput {
     instructions: string;
     userMessage: string;
     skills: import("./prompt-builder.js").SkillMetadata[];
-    /** Datastores attached via `datastore_usages` — the `<available_datastores>` section. */
-    datastoreUsages?: import("@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb").DatastoreUsage[];
     /**
      * Serving proactive channels + their templates (the DD-006 D2
      * discovery read) — the `<available_channel_templates>` section.
@@ -63,6 +61,12 @@ export interface BuildPromptInput {
      * catchup — it rides both the enhanced prompt and a resumed turn's prefix.
      */
     vision?: import("./prompt-builder.js").VisionPromptInfo;
+    /**
+     * What kind of URL the turn's storage backend mints (issue #532) — keys
+     * the input-files hand-off wording. Sourced from the resolved
+     * artifactStorage's self-description; absent when no storage resolved.
+     */
+    downloadUrlKind?: import("../../shared/attachment-download-urls.js").DownloadUrlKind;
     pendingApprovals: import("@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb").PendingApproval[];
     /**
      * Approved whole-file writes the runner already applied itself (exact-apply).
@@ -107,6 +111,15 @@ export interface BuildPromptInput {
      * usually blank.
      */
     conversationCatchup?: string;
+    /**
+     * The turn's recorded transcript rendered as digest lines
+     * (turn-recovery.ts), composed from `status.messages` at the call site.
+     * Consumed ONLY by the HITL-recovery shape — a fresh agent that replaced
+     * a lost one mid-HITL needs the story of the work it no longer remembers
+     * (issue #366); every other shape either has native context or no prior
+     * work to tell.
+     */
+    turnRecoveryDigest?: string;
 }
 /**
  * Select and build the appropriate prompt based on resolution reason and
@@ -117,20 +130,47 @@ export interface BuildPromptInput {
  * volume, or cloud server-side state) — there is no separate continuation
  * store. The prompt therefore depends only on how the agent was resolved:
  *
- * 1. HITL reinvocation        -> buildReinvocationPrompt (approval decisions;
- *                                 the resumed agent's native context carries
- *                                 the prior conversation)
- * 2. resumed_successfully      -> raw userMessage (native context carries it)
- * 3. first execution / fresh   -> buildEnhancedPrompt (full instructions +
+ * 1. HITL reinvocation,        -> buildReinvocationPrompt (approval decisions
+ *    resumed agent                 only; the resumed agent's native context
+ *                                  carries the prior conversation)
+ * 2. HITL reinvocation,        -> buildHitlRecoveryPrompt (full context +
+ *    fresh agent after            the turn's recorded transcript + decisions;
+ *    resume failure               the replacement agent's conversation is
+ *                                 empty, and both fresh-agent crossings —
+ *                                 resolution-time resume failure and mid-send
+ *                                 poisoned-handle recovery — land here by
+ *                                 keying on the reason, issue #366)
+ * 3. resumed_successfully      -> raw userMessage (native context carries it)
+ * 4. first execution / fresh   -> buildEnhancedPrompt (full instructions +
  *    agent after resume failure   skills; no prior conversation to inherit)
  */
 /**
  * Whether this activity invocation is a HITL re-invocation — the turn resumes
  * an agent purely to convey approval decisions, carrying NO user message.
- * The single discriminator for everything that must ride with the user's
- * message and nothing else: the reinvocation prompt shape (below) and the
- * vision payload (images accompany the message; a resumed agent already holds
- * them in its native conversation).
+ * Discriminates the two surfaces that depend on the agent already holding
+ * this turn's content natively — the prompt shape (below) and the primary
+ * send's vision payload — but never alone: both pair it with
+ * `resolution.reason`, because a FRESH agent mid-HITL holds nothing and
+ * needs the full re-delivery (issue #366).
  */
 export declare function isHitlReinvocation(approvalDecisions: Map<string, ApprovalAction> | undefined): approvalDecisions is Map<string, ApprovalAction>;
+/**
+ * Whether the PRIMARY send delivers the turn's vision payload. The invariant
+ * is "images accompany the user's turn message, wherever the conversation
+ * does not already hold them" — so the only send that skips them is a HITL
+ * re-invocation of a successfully RESUMED agent, whose native conversation
+ * carries the images from the original send. A fresh agent mid-HITL
+ * (resolution-time resume failure — issue #366's vision corollary) holds
+ * nothing and needs the re-delivery. The mid-send recovery retries always
+ * run on a fresh agent, so their send sites carry the payload
+ * unconditionally rather than consulting this.
+ */
+export declare function primarySendCarriesImages(approvalDecisions: Map<string, ApprovalAction> | undefined, reason: AgentResolutionReason): boolean;
+/**
+ * Append the structured-output contract to a prompt when the execution
+ * requests one. A per-turn directive (the buildFromPlan rule): it must ride
+ * every prompt this turn sends — the primary send AND the poisoned-handle
+ * recovery rebuild, which previously lost it (issue #366 ride-along).
+ */
+export declare function appendStructuredOutputDirective(basePrompt: string, schema: Record<string, unknown> | undefined): string;
 export declare function buildPrompt(input: BuildPromptInput): string;

package/dist/activities/execute-cursor/index.js

@@ -56,7 +56,6 @@ import { StreamingUpdateScheduler, loadStreamingConfig } from "../../shared/stre
 import { createCursorEventRecorder } from "./cursor-event-recorder.js";
 import { resolveMcpServers, toCursorMcpConfig, validateMcpServerEnv } from "./mcp-resolver.js";
 import { resolveMcpTransportPosture } from "../../shared/mcp-transport-guard.js";
-import { synthesizeDatastoreAttachment } from "../../shared/datastore-attachment.js";
 import { discoverChannelMessaging, synthesizeChannelAttachment, } from "../../shared/channel-attachment.js";
 import { readChannelConversationId, synthesizeConversationAttachment, } from "../../shared/conversation-attachment.js";
 import { injectSynthesizedAttachment } from "../../shared/synthesized-attachment.js";
@@ -70,7 +69,8 @@ import { buildCursorSubAgentDefinitions } from "./subagent-config.js";
 import { resolveSkills } from "./skill-resolver.js";
 import { removeStigmerSymlink } from "../../shared/workspace/stigmer-link.js";
 import { resolveAttachments } from "./attachment-resolver.js";
-import { buildEnhancedPrompt, buildReinvocationPrompt, formatConversationCatchupSection, formatInputFiles, formatInteractionModePrefix, formatImplementPlanSection } from "./prompt-builder.js";
+import { buildEnhancedPrompt, buildHitlRecoveryPrompt, buildReinvocationPrompt, formatConversationCatchupSection, formatInputFiles, formatInteractionModePrefix, formatImplementPlanSection } from "./prompt-builder.js";
+import { composeTurnRecoveryDigest } from "./turn-recovery.js";
 import { installHitlGate, removeHitlGate } from "./workspace-setup.js";
 import { ensureHitlDir } from "../../shared/workspace/platform-dir.js";
 import { acquireWorkspaceLock, WorkspaceLockCancelledError, WorkspaceLockTimeoutError, } from "../../shared/workspace/workspace-lock.js";
@@ -554,32 +554,16 @@ turnSeq) {
         const attachmentCredential = exchangedRunnerToken
             ?? config.stigmerTokenRef?.current
             ?? config.stigmerToken;
-        // Phase 4a2: Synthesize the datastore records attachment (T05).
-        // Deliberately AFTER resolve + backfill: the attachment has no
-        // McpServerUsage and reports discovered capabilities, so the
-        // backfill's destructiveHint tightener can never force-gate
-        // delete_record (which on channels would be silently skipped).
-        // Empty approval maps keep it approval-free by construction.
-        if (blueprint.datastoreUsages.length > 0) {
-            const attachment = synthesizeDatastoreAttachment(blueprint.datastoreUsages, {
-                bridgeEndpoint: config.mcpBridgeEndpoint,
-                credential: attachmentCredential,
-                backendEndpoint: config.stigmerBackendEndpoint,
-            });
-            if (attachment) {
-                const resolvedServers = injectSynthesizedAttachment(mcpResolution.resolvedServers, attachment, "datastore records");
-                mcpResolution = {
-                    resolvedServers,
-                    cursorConfig: toCursorMcpConfig(resolvedServers),
-                };
-            }
-        }
-        // Phase 4a3: Synthesize the channel messaging attachment (DD-006
-        // D7/D8), the records attachment's twin. The discovery read is the
-        // attachment decision — the control plane runs the SAME candidate
-        // computation the send authorization uses — and every failure mode
-        // (no channel, OSS, registry down, pre-3a control plane) degrades
-        // to honest absence: no tool, no section, execution unharmed.
+        // Phase 4a2: Synthesize the channel messaging attachment (DD-006
+        // D7/D8). Deliberately AFTER resolve + backfill: the attachment has
+        // no McpServerUsage and reports discovered capabilities, so the
+        // backfill's destructiveHint tightener can never force-gate its
+        // tools; empty approval maps keep it approval-free by construction.
+        // The discovery read is the attachment decision — the control plane
+        // runs the SAME candidate computation the send authorization uses —
+        // and every failure mode (no channel, OSS, registry down, pre-3a
+        // control plane) degrades to honest absence: no tool, no section,
+        // execution unharmed.
         const channelMessaging = await discoverChannelMessaging(client, exchangedRunnerToken);
         if (channelMessaging.length > 0) {
             const attachment = synthesizeChannelAttachment(channelMessaging, {
@@ -667,6 +651,7 @@ turnSeq) {
         const attachmentEntries = attachmentResults.map((a) => ({
             path: a.relativePath,
             ...(a.renamedFrom !== undefined ? { renamedFrom: a.renamedFrom } : {}),
+            ...(a.downloadUrl !== undefined ? { downloadUrl: a.downloadUrl } : {}),
         }));
         // Vision facts, derived once from the single resolution result: the
         // images the model will see inline (in attachment order) and the ones
@@ -961,13 +946,13 @@ turnSeq) {
             instructions: blueprint.instructions,
             userMessage: spec.message,
             skills: skillMetadata,
-            datastoreUsages: blueprint.datastoreUsages,
             channelMessaging,
             subAgents: blueprint.subAgents,
             workspaceDirs: blueprint.workspaceDirs,
             workspaceFileRefs: spec.workspaceFileRefs ?? [],
             attachments: attachmentEntries,
             vision: visionPromptInfo,
+            downloadUrlKind: artifactStorage?.downloadUrlKind,
             pendingApprovals: adjudicatedApprovals,
             appliedToolCallIds,
             interactionMode,
@@ -976,25 +961,36 @@ turnSeq) {
             senderIdentity: readSenderIdentity(blueprint.sessionSpec.metadata),
             sessionContext: readSessionContext(blueprint.sessionSpec.metadata),
             conversationCatchup: readConversationCatchup(spec.conversationCatchup),
+            // The turn's recorded transcript, seeded from the persisted execution
+            // on a reinvocation (Phase 3). Consumed only by the HITL-recovery
+            // shape — reached from HERE when the stored handle failed to resume
+            // at resolution time (issue #366 crossing 2).
+            turnRecoveryDigest: isReinvocation
+                ? composeTurnRecoveryDigest(status.messages)
+                : undefined,
         });
-        // Phase 10a: Inject structured output instruction for Cursor harness
-        let effectivePrompt = prompt;
-        if (structuredOutputSchema) {
-            const schemaStr = JSON.stringify(structuredOutputSchema, null, 2);
-            effectivePrompt += `\n\n---\nCRITICAL OUTPUT REQUIREMENT:\nYour final response MUST be a single valid JSON object (no markdown, no commentary, no code fences) that matches this schema:\n${schemaStr}\n\nRespond with ONLY the JSON object. Nothing else.`;
-        }
+        // Phase 10a: Inject the structured output instruction for the Cursor
+        // harness. A per-turn directive, so like buildFromPlan it must ride every
+        // prompt this turn sends — the primary AND the poisoned-handle recovery
+        // rebuild (the transport retry re-sends effectivePrompt and inherits it).
+        const withStructuredOutputDirective = (basePrompt) => appendStructuredOutputDirective(basePrompt, structuredOutputSchema);
+        const effectivePrompt = withStructuredOutputDirective(prompt);
         // Phase 10a1: The turn's vision payload. The invariant is "images
-        // accompany the user's turn message — where the message goes, they go":
-        // every send that delivers this turn's message carries them (the primary
-        // send and both fresh-agent recovery retries, whose empty conversations
-        // genuinely need the re-send), while a HITL re-invocation — whose prompt
-        // carries no user message and whose resumed agent already holds the
-        // images in its native conversation — carries none. Computed ONCE here so
-        // all send sites agree by construction.
-        const turnImages = isHitlReinvocation(approvalDecisions)
-            ? []
-            : toCursorImages(visionImages);
-        const toSendMessage = (sendPrompt) => turnImages.length > 0 ? { text: sendPrompt, images: turnImages } : sendPrompt;
+        // accompany the user's turn message, wherever the conversation does not
+        // already hold them" (primarySendCarriesImages): the ONLY send that
+        // skips them is a HITL re-invocation of a successfully RESUMED agent,
+        // whose native conversation carries the images from the original send.
+        // Every send that starts an empty conversation re-delivers them — the
+        // ordinary first/fresh-agent primary send, the HITL primary send after a
+        // resolution-time resume failure, and both mid-send recovery retries
+        // (which always run on a fresh agent, so their sites pass turnImages
+        // unconditionally). Attachments re-resolve on every invocation
+        // (Phase 5b), so the bytes are in hand even on a re-invocation.
+        const turnImages = toCursorImages(visionImages);
+        const primarySendImages = primarySendCarriesImages(approvalDecisions, resolution.reason)
+            ? turnImages
+            : [];
+        const toSendMessage = (sendPrompt, images) => images.length > 0 ? { text: sendPrompt, images } : sendPrompt;
         // Phase 10a2: Log Stigmer preamble size for context trimming diagnostics
         const promptChars = effectivePrompt.length;
         const promptEstimatedTokens = Math.ceil(promptChars / 4);
@@ -1095,7 +1091,7 @@ turnSeq) {
         // The stall watchdog is armed inside consumeCursorTurnStream (it needs the
         // run to cancel), stored on turnState.stallWatchdog so this shared onDelta can
         // reset it and the activity's finally can stop it as a backstop.
-        const run = await resolution.agent.send(toSendMessage(effectivePrompt), {
+        const run = await resolution.agent.send(toSendMessage(effectivePrompt, primarySendImages), {
             onDelta: (event) => {
                 if (!turnFirstEventEmitted) {
                     turnFirstEventEmitted = true;
@@ -1412,10 +1408,11 @@ turnSeq) {
             // poisoned-handle path leaked the fresh agent — it closed the stale one.)
             resolution = { ...resolution, agent: freshAgent, agentId: freshAgent.agentId, isNew: true };
             turnState.streamErrorMessage = undefined;
-            // The retry carries the turn's images too (same toSendMessage): the
-            // fresh agent's conversation is empty, so skipping them here would
-            // silently lose the user's photo on a recovered turn.
-            const retryRun = await freshAgent.send(toSendMessage(retryPrompt), {
+            // The retry always carries the turn's full image payload — never the
+            // primary send's HITL-trimmed set: the fresh agent's conversation is
+            // empty, so skipping them here would silently lose the user's photo on
+            // a recovered turn (issue #366's vision corollary).
+            const retryRun = await freshAgent.send(toSendMessage(retryPrompt, turnImages), {
                 onDelta: makeCursorTurnOnDelta(onDeltaDeps),
             });
             await consumeCursorTurnStream(retryRun, streamDeps);
@@ -1524,14 +1521,18 @@ turnSeq) {
                         instructions: blueprint.instructions,
                         userMessage: spec.message,
                         skills: skillMetadata,
-                        datastoreUsages: blueprint.datastoreUsages,
                         channelMessaging,
                         subAgents: blueprint.subAgents,
                         workspaceDirs: blueprint.workspaceDirs,
                         workspaceFileRefs: spec.workspaceFileRefs ?? [],
                         attachments: attachmentEntries,
                         vision: visionPromptInfo,
+                        downloadUrlKind: artifactStorage?.downloadUrlKind,
                         pendingApprovals: adjudicatedApprovals,
+                        // Without the applied set, the HITL-recovery prompt would tell
+                        // the fresh agent to carry out writes the runner already
+                        // exact-applied (the primary call at Phase 10 passes it too).
+                        appliedToolCallIds,
                         interactionMode,
                         // buildFromPlan was silently dropped here until T03 Sitting 3 —
                         // a build turn that hit handle recovery lost its directive. The
@@ -1542,6 +1543,10 @@ turnSeq) {
                         senderIdentity: readSenderIdentity(blueprint.sessionSpec.metadata),
                         sessionContext: readSessionContext(blueprint.sessionSpec.metadata),
                         conversationCatchup: readConversationCatchup(spec.conversationCatchup),
+                        // Composed fresh (not reused from Phase 10): the failed primary
+                        // stream may have appended partial work onto status.messages,
+                        // and the replacement agent should know about that too.
+                        turnRecoveryDigest: composeTurnRecoveryDigest(status.messages),
                     });
                     console.log(`ExecuteCursor retry with fresh agent: execution=${executionId}, ` +
                         `newAgentId=${freshAgent.agentId}`);
@@ -1554,7 +1559,11 @@ turnSeq) {
                     catch (updateErr) {
                         console.warn("Failed to update session with fresh agentId (non-fatal):", updateErr);
                     }
-                    const outcome = await runRecoveryStream(freshAgent, freshPrompt);
+                    // Same per-turn directive rule as buildFromPlan above: a
+                    // structured-output turn keeps its output contract on the rebuilt
+                    // prompt (the transport retry re-sends effectivePrompt and
+                    // inherits it without help).
+                    const outcome = await runRecoveryStream(freshAgent, withStructuredOutputDirective(freshPrompt));
                     if (!outcome.proceeded) {
                         if (outcome.terminal.kind === "return")
                             return slimStatus(status);
@@ -1986,30 +1995,95 @@ function seedCursorTranscriptFromExecution(status, execution) {
  * volume, or cloud server-side state) — there is no separate continuation
  * store. The prompt therefore depends only on how the agent was resolved:
  *
- * 1. HITL reinvocation        -> buildReinvocationPrompt (approval decisions;
- *                                 the resumed agent's native context carries
- *                                 the prior conversation)
- * 2. resumed_successfully      -> raw userMessage (native context carries it)
- * 3. first execution / fresh   -> buildEnhancedPrompt (full instructions +
+ * 1. HITL reinvocation,        -> buildReinvocationPrompt (approval decisions
+ *    resumed agent                 only; the resumed agent's native context
+ *                                  carries the prior conversation)
+ * 2. HITL reinvocation,        -> buildHitlRecoveryPrompt (full context +
+ *    fresh agent after            the turn's recorded transcript + decisions;
+ *    resume failure               the replacement agent's conversation is
+ *                                 empty, and both fresh-agent crossings —
+ *                                 resolution-time resume failure and mid-send
+ *                                 poisoned-handle recovery — land here by
+ *                                 keying on the reason, issue #366)
+ * 3. resumed_successfully      -> raw userMessage (native context carries it)
+ * 4. first execution / fresh   -> buildEnhancedPrompt (full instructions +
  *    agent after resume failure   skills; no prior conversation to inherit)
  */
 /**
  * Whether this activity invocation is a HITL re-invocation — the turn resumes
  * an agent purely to convey approval decisions, carrying NO user message.
- * The single discriminator for everything that must ride with the user's
- * message and nothing else: the reinvocation prompt shape (below) and the
- * vision payload (images accompany the message; a resumed agent already holds
- * them in its native conversation).
+ * Discriminates the two surfaces that depend on the agent already holding
+ * this turn's content natively — the prompt shape (below) and the primary
+ * send's vision payload — but never alone: both pair it with
+ * `resolution.reason`, because a FRESH agent mid-HITL holds nothing and
+ * needs the full re-delivery (issue #366).
  */
 export function isHitlReinvocation(approvalDecisions) {
     return approvalDecisions !== undefined && approvalDecisions.size > 0;
 }
+/**
+ * Whether the PRIMARY send delivers the turn's vision payload. The invariant
+ * is "images accompany the user's turn message, wherever the conversation
+ * does not already hold them" — so the only send that skips them is a HITL
+ * re-invocation of a successfully RESUMED agent, whose native conversation
+ * carries the images from the original send. A fresh agent mid-HITL
+ * (resolution-time resume failure — issue #366's vision corollary) holds
+ * nothing and needs the re-delivery. The mid-send recovery retries always
+ * run on a fresh agent, so their send sites carry the payload
+ * unconditionally rather than consulting this.
+ */
+export function primarySendCarriesImages(approvalDecisions, reason) {
+    return !(isHitlReinvocation(approvalDecisions) && reason === "resumed_successfully");
+}
+/**
+ * Append the structured-output contract to a prompt when the execution
+ * requests one. A per-turn directive (the buildFromPlan rule): it must ride
+ * every prompt this turn sends — the primary send AND the poisoned-handle
+ * recovery rebuild, which previously lost it (issue #366 ride-along).
+ */
+export function appendStructuredOutputDirective(basePrompt, schema) {
+    if (!schema)
+        return basePrompt;
+    const schemaStr = JSON.stringify(schema, null, 2);
+    return basePrompt + `\n\n---\nCRITICAL OUTPUT REQUIREMENT:\nYour final response MUST be a single valid JSON object (no markdown, no commentary, no code fences) that matches this schema:\n${schemaStr}\n\nRespond with ONLY the JSON object. Nothing else.`;
+}
 export function buildPrompt(input) {
     const { resolution, approvalDecisions, instructions, userMessage, skills, subAgents, workspaceDirs, workspaceFileRefs, attachments, interactionMode, buildFromPlan, conversationCatchup, } = input;
-    // HITL reinvocation: the agent is resumed, so its native context carries the
-    // prior conversation; the reinvocation prompt conveys the approval decisions
-    // (and which approved writes the runner already exact-applied).
+    // HITL reinvocation: the decisions-only prompt is correct ONLY while the
+    // agent's native context still carries the prior conversation — which only
+    // resumed_successfully guarantees. Any other reason means a fresh agent
+    // mid-HITL (in practice created_after_resume_failure: the stored handle
+    // failed to resume, or a poisoned handle was replaced mid-send), which
+    // gets the full recovery shape instead — enhanced context + the turn's
+    // recorded transcript + the same decisions — because the bare decisions on
+    // an empty conversation strand the agent with instructions and no story,
+    // and the session inherits that amnesia permanently (issue #366).
     if (isHitlReinvocation(approvalDecisions)) {
+        if (resolution.reason !== "resumed_successfully") {
+            return buildHitlRecoveryPrompt({
+                instructions,
+                userMessage,
+                skills,
+                channelMessaging: input.channelMessaging ?? [],
+                subAgents,
+                workspaceDirs,
+                workspaceFileRefs,
+                attachments,
+                vision: input.vision,
+                downloadUrlKind: input.downloadUrlKind,
+                interactionMode,
+                buildFromPlan,
+                contextBridge: input.contextBridge,
+                senderIdentity: input.senderIdentity,
+                sessionContext: input.sessionContext,
+                conversationCatchup,
+            }, {
+                turnDigest: input.turnRecoveryDigest,
+                pendingApprovals: input.pendingApprovals,
+                approvalDecisions,
+                appliedToolCallIds: input.appliedToolCallIds,
+            });
+        }
         return buildReinvocationPrompt(input.pendingApprovals, approvalDecisions, input.appliedToolCallIds);
     }
     // A successfully resumed agent carries its own conversation context via the
@@ -2031,7 +2105,7 @@ export function buildPrompt(input) {
             formatInteractionModePrefix(interactionMode),
             formatImplementPlanSection(buildFromPlan, attachments),
             attachments.length > 0
-                ? formatInputFiles(attachments, input.vision)
+                ? formatInputFiles(attachments, input.vision, input.downloadUrlKind)
                 : undefined,
             conversationCatchup !== undefined
                 ? formatConversationCatchupSection(conversationCatchup)
@@ -2048,13 +2122,13 @@ export function buildPrompt(input) {
         instructions,
         userMessage,
         skills,
-        datastoreUsages: input.datastoreUsages ?? [],
         channelMessaging: input.channelMessaging ?? [],
         subAgents,
         workspaceDirs,
         workspaceFileRefs,
         attachments,
         vision: input.vision,
+        downloadUrlKind: input.downloadUrlKind,
         interactionMode,
         buildFromPlan,
         contextBridge: input.contextBridge,