pilotswarm-sdk 0.1.13 → 0.1.14

package/dist/orchestration.js

@@ -28,6 +28,23 @@ function optionalBoolean(value) {
 function isSubAgentTerminalStatus(status) {
     return status === "completed" || status === "failed" || status === "cancelled";
 }
+const COPILOT_CONNECTION_CLOSED_MAX_RETRIES = 3;
+const COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS = 15;
+function isCopilotConnectionClosedError(message) {
+    return /\bConnection is closed\b/i.test(String(message || ""));
+}
+function buildConnectionClosedRetryDetail(retryAttempt) {
+    return `Live Copilot connection lost; retry ${retryAttempt}/${COPILOT_CONNECTION_CLOSED_MAX_RETRIES} in ${COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS}s.`;
+}
+function buildLossyHandoffSummary(errorMessage) {
+    return `Live Copilot connection stayed closed after ${COPILOT_CONNECTION_CLOSED_MAX_RETRIES} retries; ` +
+        `dehydrating for handoff to a new worker. Last error: ${errorMessage}`;
+}
+function buildLossyHandoffRehydrationMessage(errorMessage) {
+    return `The previous worker lost the live Copilot connection and handed this session off after ` +
+        `${COPILOT_CONNECTION_CLOSED_MAX_RETRIES} retries. The LLM conversation history is preserved. ` +
+        `Review the latest durable context and continue carefully. Last transport error: ${errorMessage}`;
+}
 function updateContextUsageFromEvents(previous, events, observedAt) {
     let next = cloneContextUsage(previous);
     if (!Array.isArray(events) || events.length === 0)
@@ -165,18 +182,18 @@ function updateContextUsageFromEvents(previous, events, observedAt) {
     return next;
 }
 /**
- * Flat event loop durable session orchestration (v1.0.33).
+ * Flat event loop durable session orchestration (v1.0.36).
  *
  * Replaces the nested while loops of v1.0.31 with a single
  * drain → decide → process loop backed by a KV FIFO work buffer.
  *
  * @internal
  */
-export const CURRENT_ORCHESTRATION_VERSION = "1.0.33";
-export function* durableSessionOrchestration_1_0_33(ctx, input) {
+export const CURRENT_ORCHESTRATION_VERSION = "1.0.36";
+export function* durableSessionOrchestration_1_0_36(ctx, input) {
     const rawTraceInfo = typeof ctx.traceInfo === "function" ? ctx.traceInfo.bind(ctx) : null;
     if (rawTraceInfo) {
-        ctx.traceInfo = (message) => rawTraceInfo(`[v1.0.33] ${message}`);
+        ctx.traceInfo = (message) => rawTraceInfo(`[v1.0.36] ${message}`);
     }
     const dehydrateThreshold = input.dehydrateThreshold ?? 30;
     const idleTimeout = input.idleTimeout ?? 30;
@@ -198,6 +215,7 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
     const MAX_RETRIES = 3;
     const MAX_SUB_AGENTS = 20;
     const MAX_NESTING_LEVEL = 2;
+    const CHILD_UPDATE_BATCH_MS = 30_000;
     // ─── Sub-agent tracking ──────────────────────────────────
     let subAgents = input.subAgents ? [...input.subAgents] : [];
     let pendingToolActions = input.pendingToolActions ? [...input.pendingToolActions] : [];
@@ -324,6 +342,18 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
         }
         return { prompt: rawPrompt };
     }
+    function appendSystemContext(rawPrompt, extraSystemPrompt) {
+        if (!extraSystemPrompt)
+            return rawPrompt;
+        const extracted = extractPromptSystemContext(rawPrompt);
+        const mergedSystemPrompt = mergePrompt(extracted.systemPrompt, extraSystemPrompt);
+        if (!mergedSystemPrompt)
+            return extracted.prompt ?? rawPrompt;
+        if (extracted.prompt) {
+            return `${extracted.prompt}\n\n[SYSTEM: ${mergedSystemPrompt}]`;
+        }
+        return `[SYSTEM: ${mergedSystemPrompt}]`;
+    }
     function ensureTaskContext(sourcePrompt) {
         if (taskContext || !sourcePrompt)
             return;
@@ -394,6 +424,7 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
             ...(pendingInputQuestion ? { pendingInputQuestion } : {}),
             ...(waitingForAgentIds ? { waitingForAgentIds } : {}),
             ...(interruptedWaitTimer ? { interruptedWaitTimer } : {}),
+            ...(pendingChildDigest ? { pendingChildDigest } : {}),
             ...restOverrides,
         };
     }
@@ -469,6 +500,99 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
             content: promptText.split("\n").slice(1).join("\n").trim(),
         };
     }
+    function bufferChildUpdate(update, observedAtMs) {
+        if (!pendingChildDigest) {
+            pendingChildDigest = {
+                startedAtMs: observedAtMs,
+                updates: [],
+            };
+        }
+        const nextEntry = {
+            sessionId: update.sessionId,
+            updateType: update.updateType,
+            ...(update.content ? { content: update.content.slice(0, 2000) } : {}),
+            observedAtMs,
+        };
+        const existingIndex = pendingChildDigest.updates.findIndex((entry) => entry.sessionId === update.sessionId);
+        if (existingIndex >= 0) {
+            pendingChildDigest.updates[existingIndex] = nextEntry;
+        }
+        else {
+            pendingChildDigest.updates.push(nextEntry);
+        }
+    }
+    function clearPendingChildDigest() {
+        pendingChildDigest = null;
+    }
+    function buildPendingChildDigestSystemPrompt() {
+        if (!pendingChildDigest || pendingChildDigest.updates.length === 0)
+            return undefined;
+        const lines = pendingChildDigest.updates.map((update) => {
+            const agent = subAgents.find((entry) => entry.sessionId === update.sessionId);
+            const label = agent?.orchId ?? update.sessionId;
+            const task = agent?.task ? `Task: "${agent.task.slice(0, 120)}"\n` : "";
+            const status = agent?.status ?? update.updateType;
+            const resultText = String(update.content || agent?.result || "").trim();
+            const result = resultText ? resultText.slice(0, 240) : "(no summary)";
+            return `  - Agent ${label}\n` +
+                `    ${task}` +
+                `    Update: ${update.updateType}\n` +
+                `    Status: ${status}\n` +
+                `    Result: ${result}`;
+        });
+        return `Buffered child updates arrived during the last 30 seconds:\n${lines.join("\n")}\nReview the updates and continue your task.`;
+    }
+    function flushPendingChildDigestIntoPrompt(rawPrompt) {
+        const childDigestPrompt = buildPendingChildDigestSystemPrompt();
+        if (!childDigestPrompt)
+            return rawPrompt;
+        clearPendingChildDigest();
+        return appendSystemContext(rawPrompt, childDigestPrompt);
+    }
+    function* processPendingChildDigest() {
+        const digestPrompt = buildPendingChildDigestSystemPrompt();
+        if (!digestPrompt) {
+            clearPendingChildDigest();
+            return;
+        }
+        if (activeTimer?.type === "wait") {
+            const now = yield ctx.utcNow();
+            const remainingMs = Math.max(0, activeTimer.deadlineMs - now);
+            const remainingSec = Math.round(remainingMs / 1000);
+            const elapsedMs = activeTimer.originalDurationMs - remainingMs;
+            const elapsedSec = Math.round(elapsedMs / 1000);
+            const totalSec = Math.round(activeTimer.originalDurationMs / 1000);
+            interruptedWaitTimer = {
+                remainingSec,
+                reason: activeTimer.reason,
+                shouldRehydrate: activeTimer.shouldRehydrate ?? false,
+                waitPlan: activeTimer.waitPlan,
+            };
+            activeTimer = null;
+            clearPendingChildDigest();
+            yield* processPrompt(`[SYSTEM: Buffered child updates interrupted your ${totalSec}s timer (reason: "${interruptedWaitTimer.reason}"). ` +
+                `${elapsedSec}s elapsed, ${remainingSec}s remain. ` +
+                `Review the updates and continue your task now. The remaining wait will be resumed automatically after this turn completes.\n\n${digestPrompt}]`, true);
+            return;
+        }
+        if (activeTimer?.type === "cron") {
+            const activeCron = cronSchedule;
+            activeTimer = null;
+            clearPendingChildDigest();
+            yield* processPrompt(`[SYSTEM: Buffered child updates arrived while your recurring schedule was waiting for the next wake-up${activeCron ? ` ("${activeCron.reason}")` : ""}. ` +
+                `Review the updates and continue your task now. The recurring cron schedule remains active and will be re-armed automatically after this turn completes.\n\n${digestPrompt}]`, true);
+            return;
+        }
+        if (activeTimer?.type === "idle") {
+            activeTimer = null;
+        }
+        else if (activeTimer?.type === "agent-poll") {
+            waitingForAgentIds = null;
+            activeTimer = null;
+        }
+        clearPendingChildDigest();
+        yield* processPrompt(`[SYSTEM: ${digestPrompt}]`, true);
+    }
     function* applyChildUpdate(update) {
         ctx.traceInfo(`[orch] child update from=${update.sessionId} type=${update.updateType}`);
         const agent = subAgents.find(a => a.sessionId === update.sessionId);
@@ -547,9 +671,9 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
         return `[SYSTEM: Sub-agents completed:\n${summaries.join("\n")}]`;
     }
     // ─── Helper: dehydrate and optionally release affinity ───
-    function* dehydrateForNextTurn(reason, resetAffinity = true) {
+    function* dehydrateForNextTurn(reason, resetAffinity = true, eventData) {
         ctx.traceInfo(`[orch] dehydrating session (reason=${reason}, resetAffinity=${resetAffinity})`);
-        yield session.dehydrate(reason);
+        yield session.dehydrate(reason, eventData);
         needsHydration = true;
         preserveAffinityOnHydrate = !resetAffinity;
         if (resetAffinity) {
@@ -604,6 +728,13 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
      *  After the LLM's response turn completes, the orchestration
      *  automatically re-arms the remaining wait — no LLM action needed. */
     let interruptedWaitTimer = input.interruptedWaitTimer ?? null;
+    let pendingChildDigest = input.pendingChildDigest
+        ? {
+            startedAtMs: input.pendingChildDigest.startedAtMs,
+            ...(input.pendingChildDigest.ready ? { ready: true } : {}),
+            updates: [...(input.pendingChildDigest.updates || [])],
+        }
+        : null;
     // Reconstruct active timer from CAN input
     if (input.activeTimerState) {
         const initNow = yield ctx.utcNow();
@@ -636,6 +767,26 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
     const MAX_DRAIN_PER_TURN = 50;
     const MAX_ITERATIONS_PER_EXECUTION = 100;
     const NON_BLOCKING_TIMER_MS = 10;
+    function nextTimerCandidate(now) {
+        const candidates = [];
+        if (activeTimer) {
+            candidates.push({
+                kind: "active",
+                remainingMs: Math.max(0, activeTimer.deadlineMs - now),
+                timer: activeTimer,
+            });
+        }
+        if (pendingChildDigest && !pendingChildDigest.ready && pendingChildDigest.updates.length > 0) {
+            candidates.push({
+                kind: "child-digest",
+                remainingMs: Math.max(0, pendingChildDigest.startedAtMs + CHILD_UPDATE_BATCH_MS - now),
+            });
+        }
+        if (candidates.length === 0)
+            return null;
+        candidates.sort((left, right) => left.remainingMs - right.remainingMs);
+        return candidates[0];
+    }
     function fifoBucketKey(i) { return `fifo.${i}`; }
     function readFifoBucket(i) {
         const raw = ctx.getValue(fifoBucketKey(i));
@@ -885,26 +1036,40 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
         const seenChildUpdates = new Set();
         for (let i = 0; i < MAX_DRAIN_PER_TURN; i++) {
             let msg = null;
-            // ─── Mode 1: Active Timer — race dequeue vs timer ───
-            if (activeTimer) {
+            // ─── Mode 1: Active Timer / Child Digest — race dequeue vs timer ───
+            if (activeTimer || (pendingChildDigest && !pendingChildDigest.ready)) {
                 const now = yield ctx.utcNow();
-                const remainingMs = Math.max(0, activeTimer.deadlineMs - now);
-                if (remainingMs === 0) {
-                    stash.push({ kind: "timer", timer: { ...activeTimer }, firedAtMs: now });
-                    activeTimer = null;
+                const candidate = nextTimerCandidate(now);
+                if (!candidate)
+                    continue;
+                if (candidate.remainingMs === 0) {
+                    if (candidate.kind === "active" && candidate.timer) {
+                        stash.push({ kind: "timer", timer: { ...candidate.timer }, firedAtMs: now });
+                        activeTimer = null;
+                    }
+                    else if (pendingChildDigest && pendingChildDigest.updates.length > 0) {
+                        pendingChildDigest.ready = true;
+                        break;
+                    }
                     continue;
                 }
                 const msgTask = ctx.dequeueEvent("messages");
-                const timerTask = ctx.scheduleTimer(remainingMs);
+                const timerTask = ctx.scheduleTimer(candidate.remainingMs);
                 const race = yield ctx.race(msgTask, timerTask);
                 if (race.index === 1) {
-                    const firedAt = yield ctx.utcNow();
-                    stash.push({ kind: "timer", timer: { ...activeTimer }, firedAtMs: firedAt });
-                    activeTimer = null;
+                    if (candidate.kind === "active" && candidate.timer) {
+                        const firedAt = yield ctx.utcNow();
+                        stash.push({ kind: "timer", timer: { ...candidate.timer }, firedAtMs: firedAt });
+                        activeTimer = null;
+                    }
+                    else if (pendingChildDigest && pendingChildDigest.updates.length > 0) {
+                        pendingChildDigest.ready = true;
+                        break;
+                    }
                     continue; // keep draining — pick up queued msgs in mode 3
                 }
                 msg = typeof race.value === "string" ? JSON.parse(race.value) : race.value;
-                // activeTimer stays set — deadline unchanged
+                // activeTimer / pending child digest stay set — deadlines unchanged
                 // ─── Mode 2: Blocking Dequeue — nothing to process ──
             }
             else if (needsBlockingDequeue()) {
@@ -940,43 +1105,12 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
             // ─── Route: Child updates → apply immediately ───────
             const childUpdate = parseChildUpdate(msg.prompt);
             if (childUpdate) {
-                const key = `${childUpdate.sessionId}|${childUpdate.updateType}`;
+                const key = `${childUpdate.sessionId}|${childUpdate.updateType}|${childUpdate.content ?? ""}`;
                 if (!seenChildUpdates.has(key)) {
                     seenChildUpdates.add(key);
                     yield* applyChildUpdate(childUpdate);
-                    // Break active wait timer if >60s remaining
-                    if (activeTimer?.type === "wait") {
-                        const now = yield ctx.utcNow();
-                        const remainingMs = Math.max(0, activeTimer.deadlineMs - now);
-                        const remainingSec = Math.round(remainingMs / 1000);
-                        if (remainingSec > 60) {
-                            const elapsedMs = activeTimer.originalDurationMs - remainingMs;
-                            const elapsedSec = Math.round(elapsedMs / 1000);
-                            ctx.traceInfo(`[drain] child update during wait, ${remainingSec}s remain (>60s) — breaking timer`);
-                            stash.push({
-                                kind: "prompt",
-                                prompt: `The wait was partially completed (${elapsedSec}s elapsed, ${remainingSec}s remain). Resume the wait for the remaining ${remainingSec} seconds.`,
-                                bootstrap: true,
-                            });
-                            activeTimer = null;
-                        }
-                    }
-                    // Break active cron timer if >60s remaining
-                    if (activeTimer?.type === "cron") {
-                        const now = yield ctx.utcNow();
-                        const remainingMs = Math.max(0, activeTimer.deadlineMs - now);
-                        if (Math.round(remainingMs / 1000) > 60) {
-                            ctx.traceInfo(`[drain] child update during cron wait, >60s remain — breaking timer`);
-                            const activeCron = cronSchedule;
-                            stash.push({
-                                kind: "prompt",
-                                prompt: `[SYSTEM: A child update arrived while your recurring schedule was waiting for the next wake-up${activeCron ? ` ("${activeCron.reason}")` : ""}. ` +
-                                    `Review the update and continue your task now. The recurring cron schedule remains active and will be re-armed automatically after this turn completes.]`,
-                                bootstrap: true,
-                            });
-                            activeTimer = null;
-                        }
-                    }
+                    const childObservedAt = yield ctx.utcNow();
+                    bufferChildUpdate(childUpdate, childObservedAt);
                     // Check if all waited-for agents are now done
                     if (waitingForAgentIds) {
                         const allDone = waitingForAgentIds.every(id => {
@@ -989,6 +1123,7 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
                             // and produces a single LLM turn, matching v1.0.31 behavior.
                             queueFollowup(buildWaitForAgentsFollowup(waitingForAgentIds));
                             waitingForAgentIds = null;
+                            clearPendingChildDigest();
                             activeTimer = null;
                         }
                     }
@@ -1060,6 +1195,9 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
                     waitingForAgentIds = null;
                     activeTimer = null;
                 }
+                if (pendingChildDigest?.updates.length) {
+                    userPrompt = flushPendingChildDigestIntoPrompt(userPrompt);
+                }
                 stash.push({
                     kind: "prompt",
                     prompt: userPrompt,
@@ -1176,6 +1314,79 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
             }
             retryCount++;
             ctx.traceInfo(`[orch] runTurn FAILED (attempt ${retryCount}/${MAX_RETRIES}): ${errorMsg}`);
+            if (isCopilotConnectionClosedError(errorMsg)) {
+                if (retryCount <= COPILOT_CONNECTION_CLOSED_MAX_RETRIES) {
+                    const retryDetail = buildConnectionClosedRetryDetail(retryCount);
+                    publishStatus("error", {
+                        error: `${errorMsg} (${retryDetail})`,
+                        recoverableTransportLoss: true,
+                    });
+                    ctx.traceInfo(`[orch] live Copilot connection lost; retrying in ${COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS}s`);
+                    if (blobEnabled) {
+                        yield* dehydrateForNextTurn("error", true, {
+                            detail: retryDetail,
+                            error: errorMsg,
+                            phase: "runTurn.throw",
+                            retryAttempt: retryCount,
+                            maxRetries: COPILOT_CONNECTION_CLOSED_MAX_RETRIES,
+                            retryDelaySeconds: COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS,
+                        });
+                    }
+                    yield ctx.scheduleTimer(COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS * 1000);
+                    yield* versionedContinueAsNew(continueInput({
+                        ...(systemOnlyTurn ? {} : { prompt }),
+                        ...(requiredTool ? { requiredTool } : {}),
+                        ...(turnSystemPrompt ? { systemPrompt: turnSystemPrompt } : {}),
+                        retryCount,
+                        needsHydration: blobEnabled ? true : needsHydration,
+                    }));
+                    return;
+                }
+                const handoffMessage = buildLossyHandoffSummary(errorMsg);
+                ctx.traceInfo(`[orch] ${handoffMessage}`);
+                publishStatus("error", {
+                    error: handoffMessage,
+                    retriesExhausted: true,
+                    lossyHandoff: true,
+                });
+                yield manager.recordSessionEvent(input.sessionId, [{
+                        eventType: "session.lossy_handoff",
+                        data: {
+                            message: handoffMessage,
+                            error: errorMsg,
+                            phase: "runTurn.throw",
+                            retries: COPILOT_CONNECTION_CLOSED_MAX_RETRIES,
+                            retryDelaySeconds: COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS,
+                            nextStep: "dehydrate_and_resume_on_new_worker",
+                        },
+                    }]);
+                if (blobEnabled) {
+                    yield* dehydrateForNextTurn("lossy_handoff", true, {
+                        detail: handoffMessage,
+                        error: errorMsg,
+                        phase: "runTurn.throw",
+                        retries: COPILOT_CONNECTION_CLOSED_MAX_RETRIES,
+                        retryDelaySeconds: COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS,
+                        nextStep: "dehydrate_and_resume_on_new_worker",
+                    });
+                    yield* versionedContinueAsNew(continueInput({
+                        ...(systemOnlyTurn ? {} : { prompt }),
+                        ...(requiredTool ? { requiredTool } : {}),
+                        ...(turnSystemPrompt ? { systemPrompt: turnSystemPrompt } : {}),
+                        retryCount: 0,
+                        needsHydration: true,
+                        rehydrationMessage: buildLossyHandoffRehydrationMessage(errorMsg),
+                    }));
+                    return;
+                }
+                publishStatus("error", {
+                    error: `${handoffMessage} Durable handoff is unavailable because blob persistence is disabled.`,
+                    retriesExhausted: true,
+                    lossyHandoff: false,
+                });
+                retryCount = 0;
+                return;
+            }
             if (retryCount >= MAX_RETRIES) {
                 ctx.traceInfo(`[orch] max retries exhausted, waiting for user input`);
                 publishStatus("error", {
@@ -1191,7 +1402,14 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
             const retryDelay = 15 * Math.pow(2, retryCount - 1);
             ctx.traceInfo(`[orch] retrying in ${retryDelay}s`);
             if (blobEnabled) {
-                yield* dehydrateForNextTurn("error");
+                yield* dehydrateForNextTurn("error", true, {
+                    detail: errorMsg,
+                    error: errorMsg,
+                    phase: "runTurn.throw",
+                    retryAttempt: retryCount,
+                    maxRetries: MAX_RETRIES,
+                    retryDelaySeconds: retryDelay,
+                });
             }
             yield ctx.scheduleTimer(retryDelay * 1000);
             yield* versionedContinueAsNew(continueInput({
@@ -1584,6 +1802,7 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
                     `- You are autonomous and goal-driven. If the task implies ongoing monitoring or follow-through until done, keep yourself alive with durable timers until the goal is complete or you can no longer make progress.\n` +
                     `- If it is ambiguous whether the task should become a long-running recurring workflow, report that ambiguity back to the parent instead of guessing or asking the user directly.\n` +
                     `- When your task is complete, provide a clear summary of your findings/results.\n` +
+                    `- Prefer using \`store_fact\` for larger structured context handoffs across your session lineage. Put the durable details in facts, then pass fact keys or \`read_facts\` pointers in messages/prompts instead of pasting large context blobs.\n` +
                     `- If you write any files with write_artifact, you MUST also call export_artifact and include the artifact:// link in your response.\n` +
                     `- If you override a sub-agent model, you MUST first call list_available_models in this session and use only an exact provider:model value returned there. ` +
                     `NEVER invent, guess, shorten, or reuse a stale model name.\n` +
@@ -1828,6 +2047,75 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
                 }
                 retryCount++;
                 ctx.traceInfo(`[orch] turn returned error (attempt ${retryCount}/${MAX_RETRIES}): ${result.message}`);
+                if (isCopilotConnectionClosedError(result.message)) {
+                    if (retryCount <= COPILOT_CONNECTION_CLOSED_MAX_RETRIES) {
+                        const retryDetail = buildConnectionClosedRetryDetail(retryCount);
+                        publishStatus("error", {
+                            error: `${result.message} (${retryDetail})`,
+                            recoverableTransportLoss: true,
+                        });
+                        ctx.traceInfo(`[orch] live Copilot connection loss returned as turn error; retrying in ${COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS}s`);
+                        if (blobEnabled) {
+                            yield* dehydrateForNextTurn("error", true, {
+                                detail: retryDetail,
+                                error: result.message,
+                                phase: "turn.result.error",
+                                retryAttempt: retryCount,
+                                maxRetries: COPILOT_CONNECTION_CLOSED_MAX_RETRIES,
+                                retryDelaySeconds: COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS,
+                            });
+                        }
+                        yield ctx.scheduleTimer(COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS * 1000);
+                        yield* versionedContinueAsNew(continueInput({
+                            prompt: sourcePrompt,
+                            retryCount,
+                            needsHydration: blobEnabled ? true : needsHydration,
+                        }));
+                        return;
+                    }
+                    const handoffMessage = buildLossyHandoffSummary(result.message);
+                    ctx.traceInfo(`[orch] ${handoffMessage}`);
+                    publishStatus("error", {
+                        error: handoffMessage,
+                        retriesExhausted: true,
+                        lossyHandoff: true,
+                    });
+                    yield manager.recordSessionEvent(input.sessionId, [{
+                            eventType: "session.lossy_handoff",
+                            data: {
+                                message: handoffMessage,
+                                error: result.message,
+                                phase: "turn.result.error",
+                                retries: COPILOT_CONNECTION_CLOSED_MAX_RETRIES,
+                                retryDelaySeconds: COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS,
+                                nextStep: "dehydrate_and_resume_on_new_worker",
+                            },
+                        }]);
+                    if (blobEnabled) {
+                        yield* dehydrateForNextTurn("lossy_handoff", true, {
+                            detail: handoffMessage,
+                            error: result.message,
+                            phase: "turn.result.error",
+                            retries: COPILOT_CONNECTION_CLOSED_MAX_RETRIES,
+                            retryDelaySeconds: COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS,
+                            nextStep: "dehydrate_and_resume_on_new_worker",
+                        });
+                        yield* versionedContinueAsNew(continueInput({
+                            prompt: sourcePrompt,
+                            retryCount: 0,
+                            needsHydration: true,
+                            rehydrationMessage: buildLossyHandoffRehydrationMessage(result.message),
+                        }));
+                        return;
+                    }
+                    publishStatus("error", {
+                        error: `${handoffMessage} Durable handoff is unavailable because blob persistence is disabled.`,
+                        retriesExhausted: true,
+                        lossyHandoff: false,
+                    });
+                    retryCount = 0;
+                    return;
+                }
                 if (retryCount >= MAX_RETRIES) {
                     ctx.traceInfo(`[orch] max retries exhausted for turn error, waiting for user input`);
                     publishStatus("error", {
@@ -1837,13 +2125,20 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
                     retryCount = 0;
                     return;
                 }
+                const errorRetryDelay = 15 * Math.pow(2, retryCount - 1);
                 publishStatus("error", {
-                    error: `${result.message} (retry ${retryCount}/${MAX_RETRIES})`,
+                    error: `${result.message} (retry ${retryCount}/${MAX_RETRIES} in ${errorRetryDelay}s)`,
                 });
-                const errorRetryDelay = 15 * Math.pow(2, retryCount - 1);
                 ctx.traceInfo(`[orch] retrying in ${errorRetryDelay}s after turn error`);
                 if (blobEnabled) {
-                    yield* dehydrateForNextTurn("error");
+                    yield* dehydrateForNextTurn("error", true, {
+                        detail: result.message,
+                        error: result.message,
+                        phase: "turn.result.error",
+                        retryAttempt: retryCount,
+                        maxRetries: MAX_RETRIES,
+                        retryDelaySeconds: errorRetryDelay,
+                    });
                 }
                 yield ctx.scheduleTimer(errorRetryDelay * 1000);
                 yield* versionedContinueAsNew(continueInput({
@@ -2013,6 +2308,11 @@ export function* durableSessionOrchestration_1_0_33(ctx, input) {
             }
             return true;
         }
+        // Priority 4: buffered child digest — only after user/FIFO work is drained
+        if (pendingChildDigest?.ready && pendingChildDigest.updates.length > 0 && !waitingForAgentIds) {
+            yield* processPendingChildDigest();
+            return true;
+        }
         return false;
     }
     // ═══════════════════════════════════════════════════════════