@poncho-ai/cli 0.30.0 → 0.30.2

package/dist/{chunk-5OLH7U3C.js → chunk-FA546WPW.js}

@@ -442,6 +442,41 @@ var WEB_UI_STYLES = `
     .conversation-item .delete-btn.confirming:hover {
       color: var(--error-alt);
     }
+    .cron-section-header {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      padding: 8px 10px 4px;
+      cursor: pointer;
+      font-size: 11px;
+      font-weight: 600;
+      color: var(--fg-7);
+      text-transform: uppercase;
+      letter-spacing: 0.04em;
+      user-select: none;
+      transition: color 0.15s;
+    }
+    .cron-section-header:hover { color: var(--fg-5); }
+    .cron-section-caret {
+      display: inline-flex;
+      transition: transform 0.15s;
+    }
+    .cron-section-caret.open { transform: rotate(90deg); }
+    .cron-section-count {
+      font-weight: 400;
+      color: var(--fg-8);
+      font-size: 11px;
+    }
+    .cron-view-more {
+      padding: 6px 10px;
+      font-size: 12px;
+      color: var(--fg-7);
+      cursor: pointer;
+      text-align: center;
+      transition: color 0.15s;
+      user-select: none;
+    }
+    .cron-view-more:hover { color: var(--fg-3); }
     .sidebar-footer {
       margin-top: auto;
       padding-top: 8px;
@@ -1613,6 +1648,8 @@ var WEB_UI_STYLES = `
       line-height: 1.45;
       color: var(--fg-tool-code);
       width: 100%;
+      min-width: 0;
+      overflow: hidden;
     }
     .subagent-result-summary {
       list-style: none;
@@ -1657,6 +1694,19 @@ var WEB_UI_STYLES = `
       display: grid;
       gap: 6px;
       padding: 0 12px 10px;
+      min-width: 0;
+      overflow-x: auto;
+      overflow-wrap: break-word;
+      word-break: break-word;
+    }
+    .subagent-result-body pre {
+      max-width: 100%;
+      overflow-x: auto;
+    }
+    .subagent-result-body table {
+      max-width: 100%;
+      overflow-x: auto;
+      display: block;
     }
 
     /* Todo panel \u2014 inside composer-inner, above the input shell */
@@ -1809,6 +1859,8 @@ var getWebUiClientScript = (markedSource2) => `
         parentConversationId: null,
         todos: [],
         todoPanelCollapsed: false,
+        cronSectionCollapsed: true,
+        cronShowAll: false,
       };
 
       const agentInitial = document.body.dataset.agentInitial || "A";
@@ -2552,11 +2604,86 @@ var getWebUiClientScript = (markedSource2) => `
         }
       };
 
+      const cronCaretSvg = '<svg viewBox="0 0 12 12" fill="none" width="10" height="10"><path d="M4.5 2.75L8 6L4.5 9.25" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"></path></svg>';
+
+      const parseCronTitle = (title) => {
+        const rest = title.replace(/^[cron]s*/, "");
+        const isoMatch = rest.match(/s(d{4}-d{2}-d{2}T[d:.]+Z?)$/);
+        if (isoMatch) {
+          return { jobName: rest.slice(0, isoMatch.index).trim(), timestamp: isoMatch[1] };
+        }
+        return { jobName: rest, timestamp: "" };
+      };
+
+      const formatCronTimestamp = (isoStr) => {
+        if (!isoStr) return "";
+        try {
+          const d = new Date(isoStr);
+          if (isNaN(d.getTime())) return isoStr;
+          return d.toLocaleString(undefined, { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
+        } catch { return isoStr; }
+      };
+
+      const CRON_PAGE_SIZE = 20;
+
+      const appendCronSection = (cronConvs, needsDivider) => {
+        if (needsDivider) {
+          const divider = document.createElement("div");
+          divider.className = "sidebar-section-divider";
+          elements.list.appendChild(divider);
+        }
+
+        cronConvs.sort((a, b) => (b.updatedAt || b.createdAt || 0) - (a.updatedAt || a.createdAt || 0));
+
+        const isOpen = !state.cronSectionCollapsed;
+        const header = document.createElement("div");
+        header.className = "cron-section-header";
+        header.innerHTML =
+          '<span class="cron-section-caret' + (isOpen ? ' open' : '') + '">' + cronCaretSvg + '</span>' +
+          '<span>Cron jobs</span>' +
+          '<span class="cron-section-count">' + cronConvs.length + '</span>';
+        header.onclick = () => {
+          state.cronSectionCollapsed = !state.cronSectionCollapsed;
+          state.cronShowAll = false;
+          renderConversationList();
+        };
+        elements.list.appendChild(header);
+
+        if (state.cronSectionCollapsed) return;
+
+        const limit = state.cronShowAll ? cronConvs.length : CRON_PAGE_SIZE;
+        const visible = cronConvs.slice(0, limit);
+
+        for (const c of visible) {
+          const { jobName, timestamp } = parseCronTitle(c.title);
+          const fmtTime = formatCronTimestamp(timestamp);
+          const displayTitle = fmtTime ? jobName + " \\u00b7 " + fmtTime : c.title;
+          elements.list.appendChild(buildConversationItem(Object.assign({}, c, { title: displayTitle })));
+          appendSubagentsIfActive(c.conversationId);
+        }
+
+        if (!state.cronShowAll && cronConvs.length > CRON_PAGE_SIZE) {
+          const remaining = cronConvs.length - CRON_PAGE_SIZE;
+          const viewMore = document.createElement("div");
+          viewMore.className = "cron-view-more";
+          viewMore.textContent = "View " + remaining + " more\\u2026";
+          viewMore.onclick = () => {
+            state.cronShowAll = true;
+            renderConversationList();
+          };
+          elements.list.appendChild(viewMore);
+        }
+      };
+
       const renderConversationList = () => {
         elements.list.innerHTML = "";
         const pending = state.conversations.filter(c => c.hasPendingApprovals);
         const rest = state.conversations.filter(c => !c.hasPendingApprovals);
 
+        const isCron = (c) => c.title && c.title.startsWith("[cron]");
+        const cronConvs = rest.filter(isCron);
+        const nonCron = rest.filter(c => !isCron(c));
+
         if (pending.length > 0) {
           const label = document.createElement("div");
           label.className = "sidebar-section-label";
@@ -2575,7 +2702,7 @@ var getWebUiClientScript = (markedSource2) => `
         const latest = [];
         const previous7 = [];
         const older = [];
-        for (const c of rest) {
+        for (const c of nonCron) {
           const ts = c.updatedAt || c.createdAt || 0;
           if (ts >= startOfToday) {
             latest.push(c);
@@ -2587,6 +2714,12 @@ var getWebUiClientScript = (markedSource2) => `
         }
 
         let sectionRendered = pending.length > 0;
+
+        if (cronConvs.length > 0) {
+          appendCronSection(cronConvs, sectionRendered);
+          sectionRendered = true;
+        }
+
         const appendSection = (items, labelText) => {
           if (items.length === 0) return;
           if (sectionRendered) {
@@ -3040,6 +3173,101 @@ var getWebUiClientScript = (markedSource2) => `
           });
         } else if (willStream) {
           setStreaming(true);
+        } else if (payload.needsContinuation && !payload.conversation.parentConversationId) {
+          console.log("[poncho] Detected orphaned continuation for", conversationId, "\u2014 auto-resuming");
+          (async () => {
+            try {
+              setStreaming(true);
+              var localMsgs = state.activeMessages || [];
+              var contAssistant = {
+                role: "assistant",
+                content: "",
+                _sections: [],
+                _currentText: "",
+                _currentTools: [],
+                _toolImages: [],
+                _activeActivities: [],
+                _pendingApprovals: [],
+                metadata: { toolActivity: [] }
+              };
+              localMsgs.push(contAssistant);
+              state.activeMessages = localMsgs;
+              state._activeStreamMessages = localMsgs;
+              renderMessages(localMsgs, true);
+              var contResp = await fetch(
+                "/api/conversations/" + encodeURIComponent(conversationId) + "/messages",
+                {
+                  method: "POST",
+                  credentials: "include",
+                  headers: { "Content-Type": "application/json", "x-csrf-token": state.csrfToken },
+                  body: JSON.stringify({ continuation: true }),
+                },
+              );
+              if (!contResp.ok || !contResp.body) {
+                contAssistant._error = "Failed to resume \u2014 reload to retry";
+                setStreaming(false);
+                renderMessages(localMsgs, false);
+                return;
+              }
+              state.activeStreamConversationId = conversationId;
+              var contReader = contResp.body.getReader();
+              var contDecoder = new TextDecoder();
+              var contBuffer = "";
+              while (true) {
+                var chunk = await contReader.read();
+                if (chunk.done) break;
+                contBuffer += contDecoder.decode(chunk.value, { stream: true });
+                contBuffer = parseSseChunk(contBuffer, function(evtName, evtPayload) {
+                  if (evtName === "model:chunk" && evtPayload.content) {
+                    contAssistant.content = (contAssistant.content || "") + evtPayload.content;
+                    contAssistant._currentText += evtPayload.content;
+                  }
+                  if (evtName === "tool:started") {
+                    if (contAssistant._currentText) {
+                      contAssistant._sections.push({ type: "text", content: contAssistant._currentText });
+                      contAssistant._currentText = "";
+                    }
+                    contAssistant._currentTools.push("- start \`" + evtPayload.tool + "\`");
+                  }
+                  if (evtName === "tool:completed") {
+                    contAssistant._currentTools.push("- done \`" + evtPayload.tool + "\` (" + evtPayload.duration + "ms)");
+                  }
+                  if (evtName === "tool:error") {
+                    contAssistant._currentTools.push("- error \`" + evtPayload.tool + "\`: " + evtPayload.error);
+                  }
+                  if (evtName === "run:completed" || evtName === "run:error" || evtName === "run:cancelled") {
+                    if (contAssistant._currentTools.length > 0) {
+                      contAssistant._sections.push({ type: "tools", content: contAssistant._currentTools });
+                      contAssistant._currentTools = [];
+                    }
+                    if (contAssistant._currentText) {
+                      contAssistant._sections.push({ type: "text", content: contAssistant._currentText });
+                      contAssistant._currentText = "";
+                    }
+                    contAssistant._activeActivities = [];
+                    if (evtName === "run:error") {
+                      contAssistant._error = evtPayload.error?.message || "Something went wrong";
+                    }
+                    if (evtName === "run:completed" && evtPayload.result?.continuation === true) {
+                      // Another continuation needed \u2014 reload to pick it up
+                      loadConversation(conversationId).catch(function() {});
+                    }
+                  }
+                  renderMessages(localMsgs, true);
+                });
+              }
+              setStreaming(false);
+              renderMessages(localMsgs, false);
+              await loadConversations();
+            } catch (contErr) {
+              console.error("[poncho] Auto-continuation failed:", contErr);
+              setStreaming(false);
+              await loadConversation(conversationId).catch(function() {});
+            } finally {
+              state.activeStreamConversationId = null;
+              state._activeStreamMessages = null;
+            }
+          })();
         }
       };
 
@@ -4123,6 +4351,7 @@ var getWebUiClientScript = (markedSource2) => `
           let _totalSteps = 0;
           let _maxSteps = 0;
           let _isContinuation = false;
+          let _receivedTerminalEvent = false;
           while (true) {
           let _shouldContinue = false;
           let fetchOpts;
@@ -4452,6 +4681,7 @@ var getWebUiClientScript = (markedSource2) => `
                   }
                 }
                 if (eventName === "run:completed") {
+                  _receivedTerminalEvent = true;
                   _totalSteps += typeof payload.result?.steps === "number" ? payload.result.steps : 0;
                   if (typeof payload.result?.maxSteps === "number") _maxSteps = payload.result.maxSteps;
                   if (payload.result?.continuation === true && (_maxSteps <= 0 || _totalSteps < _maxSteps)) {
@@ -4468,10 +4698,12 @@ var getWebUiClientScript = (markedSource2) => `
                   }
                 }
                 if (eventName === "run:cancelled") {
+                  _receivedTerminalEvent = true;
                   finalizeAssistantMessage();
                   renderIfActiveConversation(false);
                 }
                 if (eventName === "run:error") {
+                  _receivedTerminalEvent = true;
                   finalizeAssistantMessage();
                   const errMsg = payload.error?.message || "Something went wrong";
                   assistantMessage._error = errMsg;
@@ -4482,7 +4714,19 @@ var getWebUiClientScript = (markedSource2) => `
               }
             });
           }
+          if (!_shouldContinue && !_receivedTerminalEvent) {
+            try {
+              const recoveryPayload = await api("/api/conversations/" + encodeURIComponent(conversationId));
+              if (recoveryPayload.needsContinuation) {
+                _shouldContinue = true;
+                console.log("[poncho] Stream ended without terminal event, server has continuation \u2014 resuming");
+              }
+            } catch (_recoverErr) {
+              console.warn("[poncho] Recovery check failed after abrupt stream end");
+            }
+          }
           if (!_shouldContinue) break;
+          _receivedTerminalEvent = false;
           _isContinuation = true;
           }
           // Update active state only if user is still on this conversation.
@@ -4756,7 +5000,7 @@ var getWebUiClientScript = (markedSource2) => `
           state: "resolved",
           resolvedDecision: decision,
         }));
-        api("/api/approvals/" + encodeURIComponent(approvalId), {
+        return api("/api/approvals/" + encodeURIComponent(approvalId), {
           method: "POST",
           body: JSON.stringify({ approved: decision === "approve" }),
         }).catch((error) => {
@@ -4804,16 +5048,54 @@ var getWebUiClientScript = (markedSource2) => `
           if (pending.length === 0) return;
           const wasStreaming = state.isStreaming;
           if (!wasStreaming) setStreaming(true);
-          pending.forEach((aid) => submitApproval(aid, decision));
+          // Mark all items as resolved in the UI immediately
+          for (const aid of pending) {
+            state.approvalRequestsInFlight[aid] = true;
+            updatePendingApproval(aid, (request) => ({
+              ...request,
+              state: "resolved",
+              resolvedDecision: decision,
+            }));
+          }
           renderMessages(state.activeMessages, state.isStreaming);
           loadConversations();
-          if (!wasStreaming && state.activeConversationId) {
-            const cid = state.activeConversationId;
-            await streamConversationEvents(cid, { liveOnly: true });
-            if (state.activeConversationId === cid) {
-              pollUntilRunIdle(cid);
-            }
+          const streamCid = !wasStreaming && state.activeConversationId
+            ? state.activeConversationId
+            : null;
+          if (streamCid) {
+            streamConversationEvents(streamCid, { liveOnly: true }).finally(() => {
+              if (state.activeConversationId === streamCid) {
+                pollUntilRunIdle(streamCid);
+              }
+            });
           }
+          // Send API calls sequentially so each store write completes
+          // before the next read (avoids last-writer-wins in serverless).
+          void (async () => {
+            for (const aid of pending) {
+              await api("/api/approvals/" + encodeURIComponent(aid), {
+                method: "POST",
+                body: JSON.stringify({ approved: decision === "approve" }),
+              }).catch((error) => {
+                const isStale = error && error.payload && error.payload.code === "APPROVAL_NOT_FOUND";
+                if (isStale) {
+                  updatePendingApproval(aid, () => null);
+                } else {
+                  const errMsg = error instanceof Error ? error.message : String(error);
+                  updatePendingApproval(aid, (request) => ({
+                    ...request,
+                    state: "pending",
+                    pendingDecision: null,
+                    resolvedDecision: null,
+                    _error: errMsg,
+                  }));
+                }
+                renderMessages(state.activeMessages, state.isStreaming);
+              }).finally(() => {
+                delete state.approvalRequestsInFlight[aid];
+              });
+            }
+          })();
           return;
         }
 
@@ -7493,12 +7775,16 @@ Set environment variables on your deployment platform:
 ANTHROPIC_API_KEY=sk-ant-...   # Required
 PONCHO_AUTH_TOKEN=your-secret  # Optional: protect your endpoint
 PONCHO_MAX_DURATION=55         # Optional: serverless timeout in seconds (enables auto-continuation)
+PONCHO_INTERNAL_SECRET=...     # Recommended on serverless: shared secret for internal callback auth
 \`\`\`
 
 When \`PONCHO_MAX_DURATION\` is set, the agent automatically checkpoints and resumes across
 request cycles when it approaches the platform timeout. The web UI and client SDK handle
 this transparently.
 
+For serverless deployments with subagents or background callbacks, use a shared state backend
+(\`upstash\`, \`redis\`, or \`dynamodb\`) instead of \`state.provider: 'local'\` / \`'memory'\`.
+
 ## Troubleshooting
 
 ### Vercel deploy issues
@@ -7506,6 +7792,7 @@ this transparently.
 - After upgrading \`@poncho-ai/cli\`, re-run \`poncho build vercel --force\` to refresh generated deploy files.
 - If Vercel fails during \`pnpm install\` due to a lockfile mismatch, run \`pnpm install --no-frozen-lockfile\` locally and commit \`pnpm-lock.yaml\`.
 - Deploy from the project root: \`vercel deploy --prod\`.
+- For subagents/background callbacks, set \`PONCHO_INTERNAL_SECRET\` and use non-local state storage.
 
 For full reference:
 https://github.com/cesr/poncho-ai
@@ -8221,7 +8508,8 @@ data: ${JSON.stringify(statusPayload)}
   await harness.initialize();
   const telemetry = new TelemetryEmitter(config?.telemetry);
   const identity = await ensureAgentIdentity2(workingDir);
-  const conversationStore = createConversationStore(resolveStateConfig(config), {
+  const stateConfig = resolveStateConfig(config);
+  const conversationStore = createConversationStore(stateConfig, {
     workingDir,
     agentId: identity.id
   });
@@ -8229,6 +8517,7 @@ data: ${JSON.stringify(statusPayload)}
   const MAX_CONCURRENT_SUBAGENTS = 5;
   const activeSubagentRuns = /* @__PURE__ */ new Map();
   const pendingSubagentApprovals = /* @__PURE__ */ new Map();
+  const approvalDecisionTracker = /* @__PURE__ */ new Map();
   const getSubagentDepth = async (conversationId) => {
     let depth = 0;
     let current = await conversationStore.get(conversationId);
@@ -8559,9 +8848,10 @@ data: ${JSON.stringify(statusPayload)}
           } catch {
           }
           if (isServerless) {
-            selfFetchWithRetry(`/api/internal/subagent/${encodeURIComponent(childConversationId)}/run`, { continuation: true }).catch(
+            const work = selfFetchWithRetry(`/api/internal/subagent/${encodeURIComponent(childConversationId)}/run`, { continuation: true }).catch(
               (err) => console.error(`[poncho][subagent] Continuation self-fetch failed:`, err instanceof Error ? err.message : err)
             );
+            doWaitUntil(work);
           } else {
             runSubagent(childConversationId, parentConversationId, task, ownerId, true).catch(
               (err) => console.error(`[poncho][subagent] Continuation failed:`, err instanceof Error ? err.message : err)
@@ -8646,8 +8936,10 @@ data: ${JSON.stringify(statusPayload)}
     }
   };
   const MAX_SUBAGENT_CALLBACK_COUNT = 20;
+  const pendingCallbackNeeded = /* @__PURE__ */ new Set();
   const triggerParentCallback = async (parentConversationId) => {
     if (activeConversationRuns.has(parentConversationId)) {
+      pendingCallbackNeeded.add(parentConversationId);
       return;
     }
     if (isServerless) {
@@ -8659,12 +8951,13 @@ data: ${JSON.stringify(statusPayload)}
     await processSubagentCallback(parentConversationId);
   };
   const CALLBACK_LOCK_STALE_MS = 5 * 60 * 1e3;
-  const processSubagentCallback = async (conversationId) => {
+  const processSubagentCallback = async (conversationId, skipLockCheck = false) => {
     const conversation = await conversationStore.get(conversationId);
     if (!conversation) return;
     const pendingResults = conversation.pendingSubagentResults ?? [];
-    if (pendingResults.length === 0) return;
-    if (conversation.runningCallbackSince) {
+    const hasOrphanedContinuation = pendingResults.length === 0 && Array.isArray(conversation._continuationMessages) && conversation._continuationMessages.length > 0 && !activeConversationRuns.has(conversationId);
+    if (pendingResults.length === 0 && !hasOrphanedContinuation) return;
+    if (!skipLockCheck && conversation.runningCallbackSince) {
       const elapsed = Date.now() - conversation.runningCallbackSince;
       if (elapsed < CALLBACK_LOCK_STALE_MS) {
         return;
@@ -8673,6 +8966,7 @@ data: ${JSON.stringify(statusPayload)}
     }
     conversation.pendingSubagentResults = [];
     conversation.runningCallbackSince = Date.now();
+    conversation.runStatus = "running";
     const callbackCount = (conversation.subagentCallbackCount ?? 0) + 1;
     conversation.subagentCallbackCount = callbackCount;
     for (const pr of pendingResults) {
@@ -8692,21 +8986,36 @@ ${resultBody}`,
     if (callbackCount > MAX_SUBAGENT_CALLBACK_COUNT) {
       console.warn(`[poncho][subagent-callback] Circuit breaker: ${callbackCount} callbacks for ${conversationId}, skipping re-run`);
       conversation.runningCallbackSince = void 0;
+      conversation.runStatus = "idle";
       await conversationStore.update(conversation);
       return;
     }
-    console.log(`[poncho][subagent-callback] Processing ${pendingResults.length} result(s) for ${conversationId} (callback #${callbackCount})`);
+    const isContinuationResume = hasOrphanedContinuation && pendingResults.length === 0;
+    console.log(`[poncho][subagent-callback] Processing ${pendingResults.length} result(s) for ${conversationId} (callback #${callbackCount})${isContinuationResume ? " (continuation resume)" : ""}`);
     const abortController = new AbortController();
     activeConversationRuns.set(conversationId, {
       ownerId: conversation.ownerId,
       abortController,
       runId: null
     });
-    const historyMessages = [...conversation.messages];
+    const prevStream = conversationEventStreams.get(conversationId);
+    if (prevStream) {
+      prevStream.finished = false;
+      prevStream.buffer = [];
+    } else {
+      conversationEventStreams.set(conversationId, {
+        buffer: [],
+        subscribers: /* @__PURE__ */ new Set(),
+        finished: false
+      });
+    }
+    const historyMessages = isContinuationResume && conversation._continuationMessages?.length ? [...conversation._continuationMessages] : [...conversation.messages];
     let assistantResponse = "";
     let latestRunId = "";
     let runContinuation = false;
     let runContinuationMessages;
+    let runContextTokens = conversation.contextTokens ?? 0;
+    let runContextWindow = conversation.contextWindow ?? 0;
     const toolTimeline = [];
     const sections = [];
     let currentTools = [];
@@ -8761,6 +9070,8 @@ ${resultBody}`,
           if (assistantResponse.length === 0 && event.result.response) {
             assistantResponse = event.result.response;
           }
+          runContextTokens = event.result.contextTokens ?? runContextTokens;
+          runContextWindow = event.result.contextWindow ?? runContextWindow;
           if (event.result.continuation) {
             runContinuation = true;
             if (event.result.continuationMessages) {
@@ -8787,6 +9098,9 @@ ${resultBody}`,
           }
           freshConv.runtimeRunId = latestRunId || freshConv.runtimeRunId;
           freshConv.runningCallbackSince = void 0;
+          freshConv.runStatus = "idle";
+          if (runContextTokens > 0) freshConv.contextTokens = runContextTokens;
+          if (runContextWindow > 0) freshConv.contextWindow = runContextWindow;
           freshConv.updatedAt = Date.now();
           await conversationStore.update(freshConv);
           if (freshConv.channelMeta && assistantResponse.length > 0) {
@@ -8809,9 +9123,14 @@ ${resultBody}`,
       }
       if (runContinuation) {
         if (isServerless) {
-          selfFetchWithRetry(`/api/internal/conversations/${encodeURIComponent(conversationId)}/subagent-callback`).catch(
+          const work = selfFetchWithRetry(`/api/internal/conversations/${encodeURIComponent(conversationId)}/subagent-callback`).catch(
             (err) => console.error(`[poncho][subagent-callback] Continuation self-fetch failed:`, err instanceof Error ? err.message : err)
           );
+          doWaitUntil(work);
+        } else {
+          processSubagentCallback(conversationId, true).catch(
+            (err) => console.error(`[poncho][subagent-callback] Continuation failed:`, err instanceof Error ? err.message : err)
+          );
         }
       }
     } catch (err) {
@@ -8819,28 +9138,38 @@ ${resultBody}`,
       const errConv = await conversationStore.get(conversationId);
       if (errConv) {
         errConv.runningCallbackSince = void 0;
+        errConv.runStatus = "idle";
         await conversationStore.update(errConv);
       }
     } finally {
       activeConversationRuns.delete(conversationId);
       finishConversationStream(conversationId);
+      const hadDeferredTrigger = pendingCallbackNeeded.delete(conversationId);
       const freshConv = await conversationStore.get(conversationId);
-      if (freshConv) {
-        if (freshConv.runningCallbackSince) {
-          freshConv.runningCallbackSince = void 0;
-          await conversationStore.update(freshConv);
-        }
-      }
-      if (freshConv?.pendingSubagentResults?.length) {
+      const hasPendingInStore = !!freshConv?.pendingSubagentResults?.length;
+      if (hadDeferredTrigger || hasPendingInStore) {
         if (isServerless) {
           selfFetchWithRetry(`/api/internal/conversations/${encodeURIComponent(conversationId)}/subagent-callback`).catch(
             (err) => console.error(`[poncho][subagent-callback] Recursive callback self-fetch failed:`, err instanceof Error ? err.message : err)
           );
         } else {
-          processSubagentCallback(conversationId).catch(
+          processSubagentCallback(conversationId, true).catch(
             (err) => console.error(`[poncho][subagent-callback] Recursive callback failed:`, err instanceof Error ? err.message : err)
           );
         }
+      } else if (freshConv?.runningCallbackSince) {
+        const afterClear = await conversationStore.clearCallbackLock(conversationId);
+        if (afterClear?.pendingSubagentResults?.length) {
+          if (isServerless) {
+            selfFetchWithRetry(`/api/internal/conversations/${encodeURIComponent(conversationId)}/subagent-callback`).catch(
+              (err) => console.error(`[poncho][subagent-callback] Post-clear callback self-fetch failed:`, err instanceof Error ? err.message : err)
+            );
+          } else {
+            processSubagentCallback(conversationId, true).catch(
+              (err) => console.error(`[poncho][subagent-callback] Post-clear callback failed:`, err instanceof Error ? err.message : err)
+            );
+          }
+        }
       }
     }
   };
@@ -9007,14 +9336,6 @@ ${resultBody}`,
           if (active && active.abortController === abortController) {
             active.runId = event.runId;
           }
-          if (typeof event.contextWindow === "number" && event.contextWindow > 0) {
-            runContextWindow = event.contextWindow;
-          }
-        }
-        if (event.type === "model:response") {
-          if (typeof event.usage?.input === "number") {
-            runContextTokens = event.usage.input;
-          }
         }
         if (event.type === "model:chunk") {
           if (currentTools.length > 0) {
@@ -9079,8 +9400,12 @@ ${resultBody}`,
           }
           checkpointedRun = true;
         }
-        if (event.type === "run:completed" && assistantResponse.length === 0 && event.result.response) {
-          assistantResponse = event.result.response;
+        if (event.type === "run:completed") {
+          if (assistantResponse.length === 0 && event.result.response) {
+            assistantResponse = event.result.response;
+          }
+          runContextTokens = event.result.contextTokens ?? runContextTokens;
+          runContextWindow = event.result.contextWindow ?? runContextWindow;
         }
         if (event.type === "run:error") {
           assistantResponse = assistantResponse || `[Error: ${event.error.message}]`;
@@ -9163,6 +9488,13 @@ ${resultBody}`,
       runConversations.delete(latestRunId);
     }
     console.log("[resume-run] complete for", conversationId);
+    const hadDeferred = pendingCallbackNeeded.delete(conversationId);
+    const postConv = await conversationStore.get(conversationId);
+    if (hadDeferred || postConv?.pendingSubagentResults?.length) {
+      processSubagentCallback(conversationId, true).catch(
+        (err) => console.error(`[poncho][subagent-callback] Post-resume callback failed:`, err instanceof Error ? err.message : err)
+      );
+    }
   };
   const messagingRoutes = /* @__PURE__ */ new Map();
   const messagingRouteRegistrar = (method, path, routeHandler) => {
@@ -9293,14 +9625,6 @@ ${resultBody}`,
             latestRunId = event.runId;
             runOwners.set(event.runId, "local-owner");
             runConversations.set(event.runId, conversationId);
-            if (typeof event.contextWindow === "number" && event.contextWindow > 0) {
-              runContextWindow = event.contextWindow;
-            }
-          }
-          if (event.type === "model:response") {
-            if (typeof event.usage?.input === "number") {
-              runContextTokens = event.usage.input;
-            }
           }
           if (event.type === "model:chunk") {
             if (currentTools.length > 0) {
@@ -9399,6 +9723,8 @@ ${resultBody}`,
             }
             runSteps = event.result.steps;
             if (typeof event.result.maxSteps === "number") runMaxSteps = event.result.maxSteps;
+            runContextTokens = event.result.contextTokens ?? runContextTokens;
+            runContextWindow = event.result.contextWindow ?? runContextWindow;
           }
           if (event.type === "run:error") {
             assistantResponse = assistantResponse || `[Error: ${event.error.message}]`;
@@ -9464,34 +9790,89 @@ ${resultBody}`,
     }
   }
   const isServerless = !!waitUntilHook;
-  const internalSecret = globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`;
+  const configuredInternalSecret = process.env.PONCHO_INTERNAL_SECRET?.trim();
+  const vercelDeploymentSecret = process.env.VERCEL_DEPLOYMENT_ID?.trim();
+  const fallbackInternalSecret = globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`;
+  const internalSecret = configuredInternalSecret || vercelDeploymentSecret || fallbackInternalSecret;
+  const isUsingEphemeralInternalSecret = !configuredInternalSecret && !vercelDeploymentSecret;
   let selfBaseUrl = process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : null;
+  if (!selfBaseUrl && process.env.VERCEL_PROJECT_PRODUCTION_URL) {
+    selfBaseUrl = `https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}`;
+  }
+  if (!selfBaseUrl && process.env.PONCHO_SELF_BASE_URL) {
+    selfBaseUrl = process.env.PONCHO_SELF_BASE_URL.replace(/\/+$/, "");
+  }
+  if (isServerless && isUsingEphemeralInternalSecret) {
+    console.warn(
+      "[poncho][serverless] No stable internal secret found. Set PONCHO_INTERNAL_SECRET to avoid intermittent internal callback failures across instances."
+    );
+  }
+  if (isServerless && !selfBaseUrl) {
+    console.warn(
+      "[poncho][serverless] No self base URL available. Set PONCHO_SELF_BASE_URL if internal background callbacks fail."
+    );
+  }
+  const stateProvider = stateConfig?.provider ?? "local";
+  if (isServerless && (stateProvider === "local" || stateProvider === "memory")) {
+    console.warn(
+      `[poncho][serverless] state.provider="${stateProvider}" may lose cross-invocation state. Prefer "upstash", "redis", or "dynamodb" for subagents/reliability.`
+    );
+  }
   const doWaitUntil = (promise) => {
     if (waitUntilHook) waitUntilHook(promise);
   };
-  const selfFetch = (path, body) => {
-    if (!selfBaseUrl) return Promise.resolve();
-    return fetch(`${selfBaseUrl}${path}`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-poncho-internal": internalSecret
-      },
-      body: body ? JSON.stringify(body) : void 0
-    }).catch((err) => {
-      console.error(`[poncho][self-fetch] Failed ${path}:`, err instanceof Error ? err.message : err);
-    });
-  };
   const selfFetchWithRetry = async (path, body, retries = 3) => {
+    if (!selfBaseUrl) {
+      console.error(`[poncho][self-fetch] Missing self base URL for ${path}`);
+      return;
+    }
+    let lastError;
     for (let attempt = 0; attempt < retries; attempt++) {
       try {
-        const result = await selfFetch(path, body);
-        return result;
+        const result = await fetch(`${selfBaseUrl}${path}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-poncho-internal": internalSecret
+          },
+          body: body ? JSON.stringify(body) : void 0
+        });
+        if (result.ok) {
+          return result;
+        }
+        const responseText = await result.text().catch(() => "");
+        lastError = new Error(
+          `HTTP ${result.status}${responseText ? `: ${responseText.slice(0, 200)}` : ""}`
+        );
       } catch (err) {
-        if (attempt === retries - 1) throw err;
-        await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
+        lastError = err;
+      }
+      if (attempt === retries - 1) {
+        break;
       }
+      await new Promise((resolveSleep) => setTimeout(resolveSleep, 1e3 * (attempt + 1)));
     }
+    if (lastError) {
+      console.error(
+        `[poncho][self-fetch] Failed ${path} after ${retries} attempt(s):`,
+        lastError instanceof Error ? lastError.message : String(lastError)
+      );
+      if (lastError instanceof Error && (lastError.message.includes("HTTP 403") || lastError.message.includes("HTTP 401"))) {
+        console.error(
+          "[poncho][self-fetch] Internal auth failed. Ensure all serverless instances share PONCHO_INTERNAL_SECRET."
+        );
+      }
+    } else {
+      console.error(`[poncho][self-fetch] Failed ${path} after ${retries} attempt(s).`);
+    }
+  };
+  const getInternalRequestHeader = (headers) => {
+    const value = headers["x-poncho-internal"];
+    return Array.isArray(value) ? value[0] : value;
+  };
+  const isValidInternalRequest = (headers) => {
+    const headerValue = getInternalRequestHeader(headers);
+    return typeof headerValue === "string" && headerValue === internalSecret;
   };
   const messagingAdapters = /* @__PURE__ */ new Map();
   const messagingBridges = [];
@@ -9808,7 +10189,7 @@ ${resultBody}`,
       }
     }
     if (pathname?.startsWith("/api/internal/") && request.method === "POST") {
-      if (request.headers["x-poncho-internal"] !== internalSecret) {
+      if (!isValidInternalRequest(request.headers)) {
         writeJson(response, 403, { code: "FORBIDDEN", message: "Internal endpoint" });
         return;
       }
@@ -10187,18 +10568,29 @@ data: ${JSON.stringify(frame)}
         });
         return;
       }
+      let batchDecisions = approvalDecisionTracker.get(conversationId);
+      if (!batchDecisions) {
+        batchDecisions = /* @__PURE__ */ new Map();
+        approvalDecisionTracker.set(conversationId, batchDecisions);
+      }
+      batchDecisions.set(approvalId, approved);
       foundApproval.decision = approved ? "approved" : "denied";
       broadcastEvent(
         conversationId,
         approved ? { type: "tool:approval:granted", approvalId } : { type: "tool:approval:denied", approvalId }
       );
       const allApprovals = foundConversation.pendingApprovals ?? [];
-      const allDecided = allApprovals.length > 0 && allApprovals.every((a) => a.decision != null);
+      const allDecided = allApprovals.length > 0 && allApprovals.every((a) => batchDecisions.has(a.approvalId));
       if (!allDecided) {
         await conversationStore.update(foundConversation);
         writeJson(response, 200, { ok: true, approvalId, approved, batchComplete: false });
         return;
       }
+      for (const a of allApprovals) {
+        const d = batchDecisions.get(a.approvalId);
+        if (d != null) a.decision = d ? "approved" : "denied";
+      }
+      approvalDecisionTracker.delete(conversationId);
       foundConversation.pendingApprovals = [];
       foundConversation.runStatus = "running";
       await conversationStore.update(foundConversation);
@@ -10433,14 +10825,18 @@ data: ${JSON.stringify(frame)}
             }
           }
         }
+        const hasPendingCallbackResults = Array.isArray(conversation.pendingSubagentResults) && conversation.pendingSubagentResults.length > 0;
+        const needsContinuation = !hasActiveRun && Array.isArray(conversation._continuationMessages) && conversation._continuationMessages.length > 0;
         writeJson(response, 200, {
           conversation: {
             ...conversation,
-            pendingApprovals: storedPending
+            pendingApprovals: storedPending,
+            _continuationMessages: void 0
           },
           subagentPendingApprovals: subagentPending,
-          hasActiveRun,
-          hasRunningSubagents
+          hasActiveRun: hasActiveRun || hasPendingCallbackResults,
+          hasRunningSubagents,
+          needsContinuation
         });
         return;
       }
@@ -10820,14 +11216,6 @@ data: ${JSON.stringify(frame)}
             if (active && active.abortController === abortController) {
               active.runId = event.runId;
             }
-            if (typeof event.contextWindow === "number" && event.contextWindow > 0) {
-              runContextWindow = event.contextWindow;
-            }
-          }
-          if (event.type === "model:response") {
-            if (typeof event.usage?.input === "number") {
-              runContextTokens = event.usage.input;
-            }
           }
           if (event.type === "run:cancelled") {
             runCancelled = true;
@@ -10920,6 +11308,8 @@ data: ${JSON.stringify(frame)}
             if (assistantResponse.length === 0 && event.result.response) {
               assistantResponse = event.result.response;
             }
+            runContextTokens = event.result.contextTokens ?? runContextTokens;
+            runContextWindow = event.result.contextWindow ?? runContextWindow;
             if (event.result.continuation && event.result.continuationMessages) {
               runContinuationMessages = event.result.continuationMessages;
               conversation._continuationMessages = runContinuationMessages;
@@ -11059,9 +11449,10 @@ data: ${JSON.stringify(frame)}
           response.end();
         } catch {
         }
+        const hadDeferred = pendingCallbackNeeded.delete(conversationId);
         const freshConv = await conversationStore.get(conversationId);
-        if (freshConv?.pendingSubagentResults?.length) {
-          processSubagentCallback(conversationId).catch(
+        if (hadDeferred || freshConv?.pendingSubagentResults?.length) {
+          processSubagentCallback(conversationId, true).catch(
             (err) => console.error(`[poncho][subagent-callback] Post-run callback failed:`, err instanceof Error ? err.message : err)
           );
         }
@@ -11209,125 +11600,157 @@ ${cronJob.task}`;
             `[cron] ${jobName} ${timestamp}`
           );
         }
-        const abortController = new AbortController();
-        let assistantResponse = "";
-        let latestRunId = "";
-        const toolTimeline = [];
-        const sections = [];
-        let currentTools = [];
-        let currentText = "";
-        let runResult = {
-          status: "completed",
-          steps: 0
-        };
-        const platformMaxDurationSec = Number(process.env.PONCHO_MAX_DURATION) || 0;
-        const softDeadlineMs = platformMaxDurationSec > 0 ? platformMaxDurationSec * 800 : 0;
-        for await (const event of harness.runWithTelemetry({
-          task: cronJob.task,
-          conversationId: conversation.conversationId,
-          parameters: { __activeConversationId: conversation.conversationId },
-          messages: historyMessages,
-          abortSignal: abortController.signal
-        })) {
-          if (event.type === "run:started") {
-            latestRunId = event.runId;
-          }
-          if (event.type === "model:chunk") {
-            if (currentTools.length > 0) {
-              sections.push({ type: "tools", content: currentTools });
-              currentTools = [];
-              if (assistantResponse.length > 0 && !/\s$/.test(assistantResponse)) {
-                assistantResponse += " ";
+        const convId = conversation.conversationId;
+        activeConversationRuns.set(convId, {
+          ownerId: conversation.ownerId,
+          abortController: new AbortController(),
+          runId: null
+        });
+        try {
+          const abortController = new AbortController();
+          let assistantResponse = "";
+          let latestRunId = "";
+          const toolTimeline = [];
+          const sections = [];
+          let currentTools = [];
+          let currentText = "";
+          let runResult = {
+            status: "completed",
+            steps: 0
+          };
+          const platformMaxDurationSec = Number(process.env.PONCHO_MAX_DURATION) || 0;
+          const softDeadlineMs = platformMaxDurationSec > 0 ? platformMaxDurationSec * 800 : 0;
+          for await (const event of harness.runWithTelemetry({
+            task: cronJob.task,
+            conversationId: convId,
+            parameters: { __activeConversationId: convId },
+            messages: historyMessages,
+            abortSignal: abortController.signal
+          })) {
+            if (event.type === "run:started") {
+              latestRunId = event.runId;
+            }
+            if (event.type === "model:chunk") {
+              if (currentTools.length > 0) {
+                sections.push({ type: "tools", content: currentTools });
+                currentTools = [];
+                if (assistantResponse.length > 0 && !/\s$/.test(assistantResponse)) {
+                  assistantResponse += " ";
+                }
               }
+              assistantResponse += event.content;
+              currentText += event.content;
             }
-            assistantResponse += event.content;
-            currentText += event.content;
-          }
-          if (event.type === "tool:started") {
-            if (currentText.length > 0) {
-              sections.push({ type: "text", content: currentText });
-              currentText = "";
+            if (event.type === "tool:started") {
+              if (currentText.length > 0) {
+                sections.push({ type: "text", content: currentText });
+                currentText = "";
+              }
+              const toolText = `- start \`${event.tool}\``;
+              toolTimeline.push(toolText);
+              currentTools.push(toolText);
             }
-            const toolText = `- start \`${event.tool}\``;
-            toolTimeline.push(toolText);
-            currentTools.push(toolText);
+            if (event.type === "tool:completed") {
+              const toolText = `- done \`${event.tool}\` (${event.duration}ms)`;
+              toolTimeline.push(toolText);
+              currentTools.push(toolText);
+            }
+            if (event.type === "tool:error") {
+              const toolText = `- error \`${event.tool}\`: ${event.error}`;
+              toolTimeline.push(toolText);
+              currentTools.push(toolText);
+            }
+            if (event.type === "run:completed") {
+              runResult = {
+                status: event.result.status,
+                steps: event.result.steps,
+                continuation: event.result.continuation,
+                contextTokens: event.result.contextTokens,
+                contextWindow: event.result.contextWindow
+              };
+              if (!assistantResponse && event.result.response) {
+                assistantResponse = event.result.response;
+              }
+            }
+            broadcastEvent(convId, event);
+            await telemetry.emit(event);
           }
-          if (event.type === "tool:completed") {
-            const toolText = `- done \`${event.tool}\` (${event.duration}ms)`;
-            toolTimeline.push(toolText);
-            currentTools.push(toolText);
+          finishConversationStream(convId);
+          if (currentTools.length > 0) {
+            sections.push({ type: "tools", content: currentTools });
           }
-          if (event.type === "tool:error") {
-            const toolText = `- error \`${event.tool}\`: ${event.error}`;
-            toolTimeline.push(toolText);
-            currentTools.push(toolText);
+          if (currentText.length > 0) {
+            sections.push({ type: "text", content: currentText });
+            currentText = "";
           }
-          if (event.type === "run:completed") {
-            runResult = {
-              status: event.result.status,
-              steps: event.result.steps,
-              continuation: event.result.continuation
-            };
-            if (!assistantResponse && event.result.response) {
-              assistantResponse = event.result.response;
+          const hasContent = assistantResponse.length > 0 || toolTimeline.length > 0;
+          const assistantMetadata = toolTimeline.length > 0 || sections.length > 0 ? {
+            toolActivity: [...toolTimeline],
+            sections: sections.length > 0 ? sections : void 0
+          } : void 0;
+          const messages = [
+            ...historyMessages,
+            ...continueConversationId ? [] : [{ role: "user", content: cronJob.task }],
+            ...hasContent ? [{ role: "assistant", content: assistantResponse, metadata: assistantMetadata }] : []
+          ];
+          const freshConv = await conversationStore.get(convId);
+          if (freshConv) {
+            freshConv.messages = messages;
+            freshConv.runtimeRunId = latestRunId || freshConv.runtimeRunId;
+            if (runResult.contextTokens) freshConv.contextTokens = runResult.contextTokens;
+            if (runResult.contextWindow) freshConv.contextWindow = runResult.contextWindow;
+            freshConv.updatedAt = Date.now();
+            await conversationStore.update(freshConv);
+          }
+          if (runResult.continuation && softDeadlineMs > 0) {
+            const selfUrl = `http://${request.headers.host ?? "localhost"}${pathname}?continue=${encodeURIComponent(convId)}&continuation=${continuationCount + 1}`;
+            try {
+              const selfRes = await fetch(selfUrl, {
+                method: "GET",
+                headers: request.headers.authorization ? { authorization: request.headers.authorization } : {}
+              });
+              const selfBody = await selfRes.json();
+              writeJson(response, 200, {
+                conversationId: convId,
+                status: "continued",
+                continuations: continuationCount + 1,
+                finalResult: selfBody,
+                duration: Date.now() - start
+              });
+            } catch (continueError) {
+              writeJson(response, 200, {
+                conversationId: convId,
+                status: "continuation_failed",
+                error: continueError instanceof Error ? continueError.message : "Unknown error",
+                duration: Date.now() - start,
+                steps: runResult.steps
+              });
             }
+            return;
           }
-          await telemetry.emit(event);
-        }
-        if (currentTools.length > 0) {
-          sections.push({ type: "tools", content: currentTools });
-        }
-        if (currentText.length > 0) {
-          sections.push({ type: "text", content: currentText });
-          currentText = "";
-        }
-        const hasContent = assistantResponse.length > 0 || toolTimeline.length > 0;
-        const assistantMetadata = toolTimeline.length > 0 || sections.length > 0 ? {
-          toolActivity: [...toolTimeline],
-          sections: sections.length > 0 ? sections : void 0
-        } : void 0;
-        const messages = [
-          ...historyMessages,
-          ...continueConversationId ? [] : [{ role: "user", content: cronJob.task }],
-          ...hasContent ? [{ role: "assistant", content: assistantResponse, metadata: assistantMetadata }] : []
-        ];
-        conversation.messages = messages;
-        conversation.runtimeRunId = latestRunId || conversation.runtimeRunId;
-        conversation.updatedAt = Date.now();
-        await conversationStore.update(conversation);
-        if (runResult.continuation && softDeadlineMs > 0) {
-          const selfUrl = `http://${request.headers.host ?? "localhost"}${pathname}?continue=${encodeURIComponent(conversation.conversationId)}&continuation=${continuationCount + 1}`;
-          try {
-            const selfRes = await fetch(selfUrl, {
-              method: "GET",
-              headers: request.headers.authorization ? { authorization: request.headers.authorization } : {}
-            });
-            const selfBody = await selfRes.json();
-            writeJson(response, 200, {
-              conversationId: conversation.conversationId,
-              status: "continued",
-              continuations: continuationCount + 1,
-              finalResult: selfBody,
-              duration: Date.now() - start
-            });
-          } catch (continueError) {
-            writeJson(response, 200, {
-              conversationId: conversation.conversationId,
-              status: "continuation_failed",
-              error: continueError instanceof Error ? continueError.message : "Unknown error",
-              duration: Date.now() - start,
-              steps: runResult.steps
-            });
+          writeJson(response, 200, {
+            conversationId: convId,
+            status: runResult.status,
+            response: assistantResponse.slice(0, 500),
+            duration: Date.now() - start,
+            steps: runResult.steps
+          });
+        } finally {
+          activeConversationRuns.delete(convId);
+          const hadDeferred = pendingCallbackNeeded.delete(convId);
+          const checkConv = await conversationStore.get(convId);
+          if (hadDeferred || checkConv?.pendingSubagentResults?.length) {
+            if (isServerless) {
+              selfFetchWithRetry(`/api/internal/conversations/${encodeURIComponent(convId)}/subagent-callback`).catch(
+                (err) => console.error(`[cron] subagent callback self-fetch failed:`, err instanceof Error ? err.message : err)
+              );
+            } else {
+              processSubagentCallback(convId, true).catch(
+                (err) => console.error(`[cron] subagent callback failed:`, err instanceof Error ? err.message : err)
+              );
+            }
           }
-          return;
         }
-        writeJson(response, 200, {
-          conversationId: conversation.conversationId,
-          status: runResult.status,
-          response: assistantResponse.slice(0, 500),
-          duration: Date.now() - start,
-          steps: runResult.steps
-        });
       } catch (error) {
         writeJson(response, 500, {
           code: "CRON_RUN_ERROR",
@@ -11342,6 +11765,11 @@ ${cronJob.task}`;
   handler._cronJobs = cronJobs;
   handler._conversationStore = conversationStore;
   handler._messagingAdapters = messagingAdapters;
+  handler._activeConversationRuns = activeConversationRuns;
+  handler._pendingCallbackNeeded = pendingCallbackNeeded;
+  handler._processSubagentCallback = processSubagentCallback;
+  handler._broadcastEvent = broadcastEvent;
+  handler._finishConversationStream = finishConversationStream;
   const STALE_SUBAGENT_THRESHOLD_MS = 5 * 60 * 1e3;
   try {
     const allSummaries = await conversationStore.listSummaries();
@@ -11392,9 +11820,11 @@ var startDevServer = async (port, options) => {
   await checkVercelCronDrift(workingDir);
   const { Cron } = await import("croner");
   let activeJobs = [];
-  const runCronAgent = async (harnessRef, task, conversationId, historyMessages) => {
+  const runCronAgent = async (harnessRef, task, conversationId, historyMessages, onEvent) => {
     let assistantResponse = "";
     let steps = 0;
+    let contextTokens = 0;
+    let contextWindow = 0;
     const toolTimeline = [];
     const sections = [];
     let currentTools = [];
@@ -11405,6 +11835,7 @@ var startDevServer = async (port, options) => {
       parameters: { __activeConversationId: conversationId },
       messages: historyMessages
     })) {
+      onEvent?.(event);
       if (event.type === "model:chunk") {
         if (currentTools.length > 0) {
           sections.push({ type: "tools", content: currentTools });
@@ -11437,6 +11868,8 @@ var startDevServer = async (port, options) => {
       }
       if (event.type === "run:completed") {
         steps = event.result.steps;
+        contextTokens = event.result.contextTokens ?? 0;
+        contextWindow = event.result.contextWindow ?? 0;
         if (!assistantResponse && event.result.response) {
           assistantResponse = event.result.response;
         }
@@ -11453,7 +11886,7 @@ var startDevServer = async (port, options) => {
       toolActivity: [...toolTimeline],
       sections: sections.length > 0 ? sections : void 0
     } : void 0;
-    return { response: assistantResponse, steps, assistantMetadata, hasContent };
+    return { response: assistantResponse, steps, assistantMetadata, hasContent, contextTokens, contextWindow };
   };
   const buildCronMessages = (task, historyMessages, result) => [
     ...historyMessages,
@@ -11470,6 +11903,9 @@ var startDevServer = async (port, options) => {
     const harnessRef = handler._harness;
     const store = handler._conversationStore;
     const adapters = handler._messagingAdapters;
+    const activeRuns = handler._activeConversationRuns;
+    const deferredCallbacks = handler._pendingCallbackNeeded;
+    const runCallback = handler._processSubagentCallback;
     if (!harnessRef || !store) return;
     for (const [jobName, config] of entries) {
       const job = new Cron(
@@ -11510,24 +11946,43 @@ var startDevServer = async (port, options) => {
                 const task = `[Scheduled: ${jobName}]
 ${config.task}`;
                 const historyMessages = [...conversation.messages];
+                const convId = conversation.conversationId;
+                activeRuns?.set(convId, {
+                  ownerId: "local-owner",
+                  abortController: new AbortController(),
+                  runId: null
+                });
                 try {
-                  const result = await runCronAgent(harnessRef, task, conversation.conversationId, historyMessages);
-                  conversation.messages = buildCronMessages(task, historyMessages, result);
-                  conversation.updatedAt = Date.now();
-                  await store.update(conversation);
-                  if (result.response) {
-                    try {
-                      await adapter.sendReply(
-                        {
-                          channelId: chatId,
-                          platformThreadId: conversation.channelMeta?.platformThreadId ?? chatId
-                        },
-                        result.response
-                      );
-                    } catch (sendError) {
-                      const sendMsg = sendError instanceof Error ? sendError.message : String(sendError);
-                      process.stderr.write(`[cron] ${jobName}: send to ${chatId} failed: ${sendMsg}
+                  const broadcastCh = handler._broadcastEvent;
+                  const result = await runCronAgent(
+                    harnessRef,
+                    task,
+                    convId,
+                    historyMessages,
+                    broadcastCh ? (ev) => broadcastCh(convId, ev) : void 0
+                  );
+                  handler._finishConversationStream?.(convId);
+                  const freshConv = await store.get(convId);
+                  if (freshConv) {
+                    freshConv.messages = buildCronMessages(task, historyMessages, result);
+                    if (result.contextTokens > 0) freshConv.contextTokens = result.contextTokens;
+                    if (result.contextWindow > 0) freshConv.contextWindow = result.contextWindow;
+                    freshConv.updatedAt = Date.now();
+                    await store.update(freshConv);
+                    if (result.response) {
+                      try {
+                        await adapter.sendReply(
+                          {
+                            channelId: chatId,
+                            platformThreadId: freshConv.channelMeta?.platformThreadId ?? chatId
+                          },
+                          result.response
+                        );
+                      } catch (sendError) {
+                        const sendMsg = sendError instanceof Error ? sendError.message : String(sendError);
+                        process.stderr.write(`[cron] ${jobName}: send to ${chatId} failed: ${sendMsg}
 `);
+                      }
                     }
                   }
                   totalChats++;
@@ -11535,6 +11990,15 @@ ${config.task}`;
                   const runMsg = runError instanceof Error ? runError.message : String(runError);
                   process.stderr.write(`[cron] ${jobName}: run for chat ${chatId} failed: ${runMsg}
 `);
+                } finally {
+                  activeRuns?.delete(convId);
+                  const hadDeferred = deferredCallbacks?.delete(convId) ?? false;
+                  const checkConv = await store.get(convId);
+                  if (hadDeferred || checkConv?.pendingSubagentResults?.length) {
+                    runCallback?.(convId, true).catch(
+                      (err) => console.error(`[cron] ${jobName}: subagent callback for ${chatId} failed:`, err instanceof Error ? err.message : err)
+                    );
+                  }
                 }
               }
               const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
@@ -11548,15 +12012,35 @@ ${config.task}`;
             }
             return;
           }
+          let cronConvId;
           try {
             const conversation = await store.create(
               "local-owner",
               `[cron] ${jobName} ${timestamp}`
             );
-            const result = await runCronAgent(harnessRef, config.task, conversation.conversationId, []);
-            conversation.messages = buildCronMessages(config.task, [], result);
-            conversation.updatedAt = Date.now();
-            await store.update(conversation);
+            cronConvId = conversation.conversationId;
+            activeRuns?.set(cronConvId, {
+              ownerId: "local-owner",
+              abortController: new AbortController(),
+              runId: null
+            });
+            const broadcast = handler._broadcastEvent;
+            const result = await runCronAgent(
+              harnessRef,
+              config.task,
+              cronConvId,
+              [],
+              broadcast ? (ev) => broadcast(cronConvId, ev) : void 0
+            );
+            handler._finishConversationStream?.(cronConvId);
+            const freshConv = await store.get(cronConvId);
+            if (freshConv) {
+              freshConv.messages = buildCronMessages(config.task, [], result);
+              if (result.contextTokens > 0) freshConv.contextTokens = result.contextTokens;
+              if (result.contextWindow > 0) freshConv.contextWindow = result.contextWindow;
+              freshConv.updatedAt = Date.now();
+              await store.update(freshConv);
+            }
             const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
             process.stdout.write(
               `[cron] ${jobName} completed in ${elapsed}s (${result.steps} steps)
@@ -11569,6 +12053,17 @@ ${config.task}`;
               `[cron] ${jobName} failed after ${elapsed}s: ${msg}
 `
             );
+          } finally {
+            if (cronConvId) {
+              activeRuns?.delete(cronConvId);
+              const hadDeferred = deferredCallbacks?.delete(cronConvId) ?? false;
+              const checkConv = await store.get(cronConvId);
+              if (hadDeferred || checkConv?.pendingSubagentResults?.length) {
+                runCallback?.(cronConvId, true).catch(
+                  (err) => console.error(`[cron] ${jobName}: subagent callback failed:`, err instanceof Error ? err.message : err)
+                );
+              }
+            }
           }
         }
       );
@@ -11676,7 +12171,7 @@ var runInteractive = async (workingDir, params) => {
   await harness.initialize();
   const identity = await ensureAgentIdentity2(workingDir);
   try {
-    const { runInteractiveInk } = await import("./run-interactive-ink-EMTC7MK7.js");
+    const { runInteractiveInk } = await import("./run-interactive-ink-FUMHN6DS.js");
     await runInteractiveInk({
       harness,
       params,