@poncho-ai/cli 0.30.0 → 0.30.1

package/dist/{chunk-5OLH7U3C.js → chunk-UYZOJWGL.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) {
@@ -4756,7 +4889,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 +4937,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;
         }
 
@@ -8229,6 +8400,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);
@@ -8646,8 +8818,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 +8833,12 @@ 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) {
+    if (!skipLockCheck && conversation.runningCallbackSince) {
       const elapsed = Date.now() - conversation.runningCallbackSince;
       if (elapsed < CALLBACK_LOCK_STALE_MS) {
         return;
@@ -8702,11 +8876,24 @@ ${resultBody}`,
       abortController,
       runId: null
     });
+    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 = [...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 +8948,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 +8976,8 @@ ${resultBody}`,
           }
           freshConv.runtimeRunId = latestRunId || freshConv.runtimeRunId;
           freshConv.runningCallbackSince = void 0;
+          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) {
@@ -8824,23 +9015,32 @@ ${resultBody}`,
     } 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 +9207,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 +9271,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 +9359,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 +9496,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 +9594,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}]`;
@@ -10187,18 +10384,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);
@@ -10820,14 +11028,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 +11120,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 +11261,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 +11412,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 +11577,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 +11632,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 +11647,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 +11680,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 +11698,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 +11715,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 +11758,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 +11802,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 +11824,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 +11865,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 +11983,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-ZSIGWFLZ.js");
     await runInteractiveInk({
       harness,
       params,