@poncho-ai/cli 0.32.4 → 0.32.6

package/dist/{chunk-F6NA3N2R.js → chunk-OJGEUTDF.js}

@@ -1861,6 +1861,7 @@ var getWebUiClientScript = (markedSource2) => `
         todoPanelCollapsed: false,
         cronSectionCollapsed: true,
         cronShowAll: false,
+        subagentPollInFlight: {},
       };
 
       const agentInitial = document.body.dataset.agentInitial || "A";
@@ -2320,11 +2321,20 @@ var getWebUiClientScript = (markedSource2) => `
               return null;
             }
             const toolName = item && typeof item.tool === "string" ? item.tool : "tool";
+            const decision =
+              item && typeof item.decision === "string" ? item.decision : null;
+            const isResolved = decision === "approved" || decision === "denied";
             return {
               approvalId,
               tool: toolName,
               input: item?.input ?? {},
-              state: "pending",
+              state: isResolved ? "resolved" : "pending",
+              resolvedDecision:
+                decision === "approved"
+                  ? "approve"
+                  : decision === "denied"
+                    ? "deny"
+                    : null,
             };
           })
           .filter(Boolean);
@@ -3374,8 +3384,8 @@ var getWebUiClientScript = (markedSource2) => `
               updateContextRing();
               renderMessages(state.activeMessages, payload.hasActiveRun);
             }
-            if (payload.hasActiveRun) {
-              if (window._connectBrowserStream) window._connectBrowserStream();
+            if (payload.hasActiveRun || payload.hasRunningSubagents) {
+              if (payload.hasActiveRun && window._connectBrowserStream) window._connectBrowserStream();
               setTimeout(poll, 2000);
             } else {
               setStreaming(false);
@@ -3390,9 +3400,15 @@ var getWebUiClientScript = (markedSource2) => `
       };
 
       const pollForSubagentResults = (conversationId) => {
+        if (state.subagentPollInFlight[conversationId]) return;
+        state.subagentPollInFlight[conversationId] = true;
         let lastMessageCount = state.activeMessages ? state.activeMessages.length : 0;
+        let lastUpdatedAt = 0;
         const poll = async () => {
-          if (state.activeConversationId !== conversationId) return;
+          if (state.activeConversationId !== conversationId) {
+            delete state.subagentPollInFlight[conversationId];
+            return;
+          }
           try {
             var payload = await api("/api/conversations/" + encodeURIComponent(conversationId));
             if (state.activeConversationId !== conversationId) return;
@@ -3413,13 +3429,17 @@ var getWebUiClientScript = (markedSource2) => `
                   });
                 });
               }
-              if (messages.length > lastMessageCount) {
+              const conversationUpdatedAt =
+                typeof payload.conversation.updatedAt === "number" ? payload.conversation.updatedAt : 0;
+              if (messages.length > lastMessageCount || conversationUpdatedAt > lastUpdatedAt) {
                 lastMessageCount = messages.length;
+                lastUpdatedAt = conversationUpdatedAt;
                 state.activeMessages = hydratePendingApprovals(messages, allPending);
                 renderMessages(state.activeMessages, payload.hasActiveRun || payload.hasRunningSubagents);
               }
               if (payload.hasActiveRun) {
                 // Parent agent started its continuation run \u2014 switch to live stream
+                delete state.subagentPollInFlight[conversationId];
                 setStreaming(true);
                 state.activeMessages = hydratePendingApprovals(messages, allPending);
                 streamConversationEvents(conversationId, { liveOnly: true }).finally(() => {
@@ -3432,6 +3452,7 @@ var getWebUiClientScript = (markedSource2) => `
               } else {
                 renderMessages(state.activeMessages, false);
                 await loadConversations();
+                delete state.subagentPollInFlight[conversationId];
               }
             }
           } catch {
@@ -4359,6 +4380,7 @@ var getWebUiClientScript = (markedSource2) => `
           let _maxSteps = 0;
           let _receivedTerminalEvent = false;
           let _shouldContinue = false;
+          let _pendingSubagentsConversation = null;
 
           // Helper to read an SSE stream from a fetch response
           const readSseStream = async (response) => {
@@ -4676,7 +4698,7 @@ var getWebUiClientScript = (markedSource2) => `
                       assistantMessage.content = String(payload.result?.response || "");
                     }
                     if (payload.pendingSubagents) {
-                      pollForSubagentResults(conversationId);
+                      _pendingSubagentsConversation = conversationId;
                     }
                     renderIfActiveConversation(false);
                   }
@@ -4804,6 +4826,19 @@ var getWebUiClientScript = (markedSource2) => `
           }
           elements.prompt.focus();
         }
+
+        // Subagent callback: after sendMessage fully completes (including
+        // finally cleanup), reload the conversation. loadConversation is
+        // the exact same code path as a manual refresh \u2014 if the callback
+        // is still running it connects to the event stream; if it already
+        // finished it just renders the final persisted state.
+        if (_pendingSubagentsConversation && state.activeConversationId === _pendingSubagentsConversation) {
+          const cbConvId = _pendingSubagentsConversation;
+          await new Promise(r => setTimeout(r, 1200));
+          if (state.activeConversationId === cbConvId && !state.isStreaming) {
+            await loadConversation(cbConvId);
+          }
+        }
       };
 
       const requireAuth = async () => {
@@ -5037,9 +5072,22 @@ var getWebUiClientScript = (markedSource2) => `
         }));
         return api("/api/approvals/" + encodeURIComponent(approvalId), {
           method: "POST",
-          body: JSON.stringify({ approved: decision === "approve" }),
+          body: JSON.stringify({
+            approved: decision === "approve",
+            conversationId: state.activeConversationId || undefined,
+          }),
         }).catch((error) => {
           const isStale = error && error.payload && error.payload.code === "APPROVAL_NOT_FOUND";
+          const isNotReady = error && error.payload && error.payload.code === "APPROVAL_NOT_READY";
+          if (isNotReady) {
+            updatePendingApproval(approvalId, (request) => ({
+              ...request,
+              state: "pending",
+              pendingDecision: null,
+              resolvedDecision: null,
+            }));
+            return;
+          }
           if (isStale) {
             updatePendingApproval(approvalId, () => null);
           } else {
@@ -5110,9 +5158,23 @@ var getWebUiClientScript = (markedSource2) => `
             for (const aid of pending) {
               await api("/api/approvals/" + encodeURIComponent(aid), {
                 method: "POST",
-                body: JSON.stringify({ approved: decision === "approve" }),
+                body: JSON.stringify({
+                  approved: decision === "approve",
+                  conversationId: state.activeConversationId || undefined,
+                }),
               }).catch((error) => {
                 const isStale = error && error.payload && error.payload.code === "APPROVAL_NOT_FOUND";
+                const isNotReady = error && error.payload && error.payload.code === "APPROVAL_NOT_READY";
+                if (isNotReady) {
+                  updatePendingApproval(aid, (request) => ({
+                    ...request,
+                    state: "pending",
+                    pendingDecision: null,
+                    resolvedDecision: null,
+                  }));
+                  renderMessages(state.activeMessages, state.isStreaming);
+                  return;
+                }
                 if (isStale) {
                   updatePendingApproval(aid, () => null);
                 } else {
@@ -7412,6 +7474,13 @@ var readRequestBody = async (request) => {
   const body = Buffer.concat(chunks).toString("utf8");
   return body.length > 0 ? JSON.parse(body) : {};
 };
+var parseTelegramMessageThreadIdFromPlatformThreadId = (platformThreadId, chatId) => {
+  if (!platformThreadId || !chatId) return void 0;
+  const parts = platformThreadId.split(":");
+  if (parts.length !== 3 || parts[0] !== chatId) return void 0;
+  const threadId = Number(parts[1]);
+  return Number.isInteger(threadId) ? threadId : void 0;
+};
 var MAX_UPLOAD_SIZE = 25 * 1024 * 1024;
 var parseMultipartRequest = (request) => new Promise((resolve4, reject) => {
   const result = { message: "", files: [] };
@@ -7546,6 +7615,209 @@ var normalizeMessageForClient = (message) => {
   }
   return message;
 };
+var isMessageArray = (value) => Array.isArray(value) && value.every((entry) => {
+  if (!entry || typeof entry !== "object") return false;
+  const row = entry;
+  const role = row.role;
+  const content = row.content;
+  const roleOk = role === "system" || role === "user" || role === "assistant" || role === "tool";
+  const contentOk = typeof content === "string" || Array.isArray(content);
+  return roleOk && contentOk;
+});
+var loadCanonicalHistory = (conversation) => {
+  if (isMessageArray(conversation._harnessMessages) && conversation._harnessMessages.length > 0) {
+    return { messages: [...conversation._harnessMessages], source: "harness" };
+  }
+  return { messages: [...conversation.messages], source: "messages" };
+};
+var loadRunHistory = (conversation, options) => {
+  if (options?.preferContinuation && isMessageArray(conversation._continuationMessages) && conversation._continuationMessages.length > 0) {
+    return {
+      messages: [...conversation._continuationMessages],
+      source: "continuation",
+      shouldRebuildCanonical: !isMessageArray(conversation._harnessMessages) || conversation._harnessMessages.length === 0
+    };
+  }
+  const canonical = loadCanonicalHistory(conversation);
+  return {
+    ...canonical,
+    shouldRebuildCanonical: canonical.source !== "harness"
+  };
+};
+var createTurnDraftState = () => ({
+  assistantResponse: "",
+  toolTimeline: [],
+  sections: [],
+  currentTools: [],
+  currentText: ""
+});
+var cloneSections = (sections) => sections.map((section) => ({
+  type: section.type,
+  content: Array.isArray(section.content) ? [...section.content] : section.content
+}));
+var flushTurnDraft = (draft) => {
+  if (draft.currentTools.length > 0) {
+    draft.sections.push({ type: "tools", content: draft.currentTools });
+    draft.currentTools = [];
+  }
+  if (draft.currentText.length > 0) {
+    draft.sections.push({ type: "text", content: draft.currentText });
+    draft.currentText = "";
+  }
+};
+var recordStandardTurnEvent = (draft, event) => {
+  if (event.type === "model:chunk") {
+    if (draft.currentTools.length > 0) {
+      draft.sections.push({ type: "tools", content: draft.currentTools });
+      draft.currentTools = [];
+      if (draft.assistantResponse.length > 0 && !/\s$/.test(draft.assistantResponse)) {
+        draft.assistantResponse += " ";
+      }
+    }
+    draft.assistantResponse += event.content;
+    draft.currentText += event.content;
+    return;
+  }
+  if (event.type === "tool:started") {
+    if (draft.currentText.length > 0) {
+      draft.sections.push({ type: "text", content: draft.currentText });
+      draft.currentText = "";
+    }
+    const toolText = `- start \`${event.tool}\``;
+    draft.toolTimeline.push(toolText);
+    draft.currentTools.push(toolText);
+    return;
+  }
+  if (event.type === "tool:completed") {
+    const toolText = `- done \`${event.tool}\` (${event.duration}ms)`;
+    draft.toolTimeline.push(toolText);
+    draft.currentTools.push(toolText);
+    return;
+  }
+  if (event.type === "tool:error") {
+    const toolText = `- error \`${event.tool}\`: ${event.error}`;
+    draft.toolTimeline.push(toolText);
+    draft.currentTools.push(toolText);
+  }
+};
+var buildAssistantMetadata = (draft, sectionsOverride) => {
+  const sections = sectionsOverride ?? cloneSections(draft.sections);
+  if (draft.toolTimeline.length === 0 && sections.length === 0) return void 0;
+  return {
+    toolActivity: [...draft.toolTimeline],
+    sections: sections.length > 0 ? sections : void 0
+  };
+};
+var executeConversationTurn = async ({
+  harness,
+  runInput,
+  initialContextTokens = 0,
+  initialContextWindow = 0,
+  onEvent
+}) => {
+  const draft = createTurnDraftState();
+  let latestRunId = "";
+  let runCancelled = false;
+  let runContinuation = false;
+  let runContinuationMessages;
+  let runHarnessMessages;
+  let runContextTokens = initialContextTokens;
+  let runContextWindow = initialContextWindow;
+  let runSteps = 0;
+  let runMaxSteps;
+  for await (const event of harness.runWithTelemetry(runInput)) {
+    recordStandardTurnEvent(draft, event);
+    if (event.type === "run:started") {
+      latestRunId = event.runId;
+    }
+    if (event.type === "run:cancelled") {
+      runCancelled = true;
+    }
+    if (event.type === "run:completed") {
+      runContinuation = event.result.continuation === true;
+      runContinuationMessages = event.result.continuationMessages;
+      runHarnessMessages = event.result.continuationMessages;
+      runContextTokens = event.result.contextTokens ?? runContextTokens;
+      runContextWindow = event.result.contextWindow ?? runContextWindow;
+      runSteps = event.result.steps;
+      if (typeof event.result.maxSteps === "number") {
+        runMaxSteps = event.result.maxSteps;
+      }
+      if (draft.assistantResponse.length === 0 && event.result.response) {
+        draft.assistantResponse = event.result.response;
+      }
+    }
+    if (event.type === "run:error") {
+      draft.assistantResponse = draft.assistantResponse || `[Error: ${event.error.message}]`;
+    }
+    if (onEvent) {
+      await onEvent(event, draft);
+    }
+  }
+  return {
+    latestRunId,
+    runCancelled,
+    runContinuation,
+    runContinuationMessages,
+    runHarnessMessages,
+    runContextTokens,
+    runContextWindow,
+    runSteps,
+    runMaxSteps,
+    draft
+  };
+};
+var normalizePendingToolCalls = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => {
+    if (!entry || typeof entry !== "object") return false;
+    const row = entry;
+    return typeof row.id === "string" && typeof row.name === "string" && typeof row.input === "object" && row.input !== null;
+  }).map((entry) => ({ id: entry.id, name: entry.name, input: entry.input }));
+};
+var normalizeApprovalCheckpoint = (approval, fallbackMessages) => ({
+  ...approval,
+  checkpointMessages: isMessageArray(approval.checkpointMessages) ? approval.checkpointMessages : [...fallbackMessages],
+  baseMessageCount: typeof approval.baseMessageCount === "number" && approval.baseMessageCount >= 0 ? approval.baseMessageCount : 0,
+  pendingToolCalls: normalizePendingToolCalls(approval.pendingToolCalls)
+});
+var buildApprovalCheckpoints = ({
+  approvals,
+  runId,
+  checkpointMessages,
+  baseMessageCount,
+  pendingToolCalls
+}) => approvals.map((approval) => ({
+  approvalId: approval.approvalId,
+  runId,
+  tool: approval.tool,
+  toolCallId: approval.toolCallId,
+  input: approval.input,
+  checkpointMessages,
+  baseMessageCount,
+  pendingToolCalls
+}));
+var resolveRunRequest = (conversation, request) => {
+  const resolved = loadRunHistory(conversation, {
+    preferContinuation: request.preferContinuation
+  });
+  return {
+    source: resolved.source,
+    shouldRebuildCanonical: resolved.shouldRebuildCanonical,
+    messages: resolved.messages.length > 0 ? resolved.messages : request.messages
+  };
+};
+var __internalRunOrchestration = {
+  isMessageArray,
+  loadCanonicalHistory,
+  loadRunHistory,
+  normalizeApprovalCheckpoint,
+  buildApprovalCheckpoints,
+  resolveRunRequest,
+  createTurnDraftState,
+  recordStandardTurnEvent,
+  executeConversationTurn
+};
 var AGENT_TEMPLATE = (name, id, options) => `---
 name: ${name}
 id: ${id}
@@ -8729,6 +9001,60 @@ data: ${JSON.stringify(statusPayload)}
   const activeSubagentRuns = /* @__PURE__ */ new Map();
   const pendingSubagentApprovals = /* @__PURE__ */ new Map();
   const approvalDecisionTracker = /* @__PURE__ */ new Map();
+  const findPendingApproval = async (approvalId, owner) => {
+    const searchedConversationIds = /* @__PURE__ */ new Set();
+    const scan = async (conversations) => {
+      for (const conv of conversations) {
+        if (searchedConversationIds.has(conv.conversationId)) continue;
+        searchedConversationIds.add(conv.conversationId);
+        if (!Array.isArray(conv.pendingApprovals)) continue;
+        const match = conv.pendingApprovals.find((approval) => approval.approvalId === approvalId);
+        if (match) {
+          return { conversation: conv, approval: match };
+        }
+      }
+      return void 0;
+    };
+    const ownerScoped = await scan(await conversationStore.list(owner));
+    if (ownerScoped) return ownerScoped;
+    if (owner === "local-owner") {
+      return await scan(await conversationStore.list());
+    }
+    return void 0;
+  };
+  const hasRunningSubagentsForParent = async (parentConversationId, owner) => {
+    let hasRunning = Array.from(activeSubagentRuns.values()).some(
+      (run) => run.parentConversationId === parentConversationId
+    );
+    if (hasRunning) return true;
+    const summaries = await conversationStore.listSummaries(owner);
+    for (const summary of summaries) {
+      if (summary.parentConversationId !== parentConversationId) continue;
+      const childConversation = await conversationStore.get(summary.conversationId);
+      if (childConversation?.subagentMeta?.status === "running") {
+        hasRunning = true;
+        break;
+      }
+    }
+    return hasRunning;
+  };
+  const hasPendingSubagentWorkForParent = async (parentConversationId, owner) => {
+    if (await hasRunningSubagentsForParent(parentConversationId, owner)) {
+      return true;
+    }
+    if (pendingCallbackNeeded.has(parentConversationId)) {
+      return true;
+    }
+    const parentConversation = await conversationStore.get(parentConversationId);
+    if (!parentConversation) return false;
+    if (Array.isArray(parentConversation.pendingSubagentResults) && parentConversation.pendingSubagentResults.length > 0) {
+      return true;
+    }
+    if (typeof parentConversation.runningCallbackSince === "number" && parentConversation.runningCallbackSince > 0) {
+      return true;
+    }
+    return false;
+  };
   const getSubagentDepth = async (conversationId) => {
     let depth = 0;
     let current = await conversationStore.get(conversationId);
@@ -8772,7 +9098,9 @@ data: ${JSON.stringify(statusPayload)}
   const resumeSubagentFromCheckpoint = async (subagentId) => {
     const conv = await conversationStore.get(subagentId);
     if (!conv || !conv.parentConversationId) return;
-    const allApprovals = conv.pendingApprovals ?? [];
+    const allApprovals = (conv.pendingApprovals ?? []).map(
+      (approval) => normalizeApprovalCheckpoint(approval, conv.messages)
+    );
     if (allApprovals.length === 0) return;
     const allDecided = allApprovals.every((a) => a.decision != null);
     if (!allDecided) return;
@@ -8843,7 +9171,11 @@ data: ${JSON.stringify(statusPayload)}
       if (conversation.subagentMeta?.status === "stopped") return;
       conversation.lastActivityAt = Date.now();
       await conversationStore.update(conversation);
-      const harnessMessages = conversation._harnessMessages?.length ? [...conversation._harnessMessages] : [...conversation.messages];
+      const runOutcome = resolveRunRequest(conversation, {
+        conversationId: childConversationId,
+        messages: conversation.messages
+      });
+      const harnessMessages = [...runOutcome.messages];
       for await (const event of childHarness.runWithTelemetry({
         task,
         conversationId: childConversationId,
@@ -8905,16 +9237,13 @@ data: ${JSON.stringify(statusPayload)}
         if (event.type === "tool:approval:checkpoint") {
           const cpConv = await conversationStore.get(childConversationId);
           if (cpConv) {
-            const allCpData = event.approvals.map((a) => ({
-              approvalId: a.approvalId,
+            const allCpData = buildApprovalCheckpoints({
+              approvals: event.approvals,
               runId: latestRunId,
-              tool: a.tool,
-              toolCallId: a.toolCallId,
-              input: a.input,
               checkpointMessages: [...harnessMessages, ...event.checkpointMessages],
               baseMessageCount: 0,
               pendingToolCalls: event.pendingToolCalls
-            }));
+            });
             cpConv.pendingApprovals = allCpData;
             cpConv.updatedAt = Date.now();
             await conversationStore.update(cpConv);
@@ -8929,7 +9258,7 @@ data: ${JSON.stringify(statusPayload)}
                 });
               }
             });
-            const checkpointRef = allCpData[0];
+            const checkpointRef = normalizeApprovalCheckpoint(allCpData[0], [...harnessMessages]);
             const toolContext = {
               runId: checkpointRef.runId,
               agentId: identity.id,
@@ -9051,6 +9380,8 @@ data: ${JSON.stringify(statusPayload)}
         }
         if (runResult?.continuationMessages) {
           conv._harnessMessages = runResult.continuationMessages;
+        } else if (runOutcome.shouldRebuildCanonical) {
+          conv._harnessMessages = conv.messages;
         }
         conv._toolResultArchive = childHarness.getToolResultArchive(childConversationId);
         conv.lastActivityAt = Date.now();
@@ -9193,6 +9524,7 @@ ${resultBody}`,
         metadata: { _subagentCallback: true, subagentId: pr.subagentId, task: pr.task, timestamp: pr.timestamp }
       });
     }
+    conversation._harnessMessages = [...conversation.messages];
     conversation.updatedAt = Date.now();
     await conversationStore.update(conversation);
     if (callbackCount > MAX_SUBAGENT_CALLBACK_COUNT) {
@@ -9221,109 +9553,70 @@ ${resultBody}`,
         finished: false
       });
     }
-    const historyMessages = isContinuationResume && conversation._continuationMessages?.length ? [...conversation._continuationMessages] : conversation._harnessMessages?.length ? [...conversation._harnessMessages] : [...conversation.messages];
-    let assistantResponse = "";
-    let latestRunId = "";
-    let runContinuation2 = false;
-    let runContinuationMessages;
-    let runHarnessMessages;
-    let runContextTokens = conversation.contextTokens ?? 0;
-    let runContextWindow = conversation.contextWindow ?? 0;
-    const toolTimeline = [];
-    const sections = [];
-    let currentTools = [];
-    let currentText = "";
+    const historySelection = resolveRunRequest(conversation, {
+      conversationId,
+      messages: conversation.messages,
+      preferContinuation: isContinuationResume
+    });
+    const historyMessages = [...historySelection.messages];
+    console.info(
+      `[poncho][subagent-callback] conversation="${conversationId}" history_source=${historySelection.source}`
+    );
+    let execution;
     try {
-      for await (const event of harness.runWithTelemetry({
-        task: void 0,
-        conversationId,
-        parameters: withToolResultArchiveParam({
-          __activeConversationId: conversationId,
-          __ownerId: conversation.ownerId
-        }, conversation),
-        messages: historyMessages,
-        abortSignal: abortController.signal
-      })) {
-        if (event.type === "run:started") {
-          latestRunId = event.runId;
-          const active = activeConversationRuns.get(conversationId);
-          if (active) active.runId = 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;
-        }
-        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);
-        }
-        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") {
-          if (assistantResponse.length === 0 && event.result.response) {
-            assistantResponse = event.result.response;
-          }
-          runContextTokens = event.result.contextTokens ?? runContextTokens;
-          runContextWindow = event.result.contextWindow ?? runContextWindow;
-          if (event.result.continuationMessages) {
-            runHarnessMessages = event.result.continuationMessages;
-          }
-          if (event.result.continuation) {
-            runContinuation2 = true;
-            if (event.result.continuationMessages) {
-              runContinuationMessages = event.result.continuationMessages;
-            }
+      execution = await executeConversationTurn({
+        harness,
+        runInput: {
+          task: void 0,
+          conversationId,
+          parameters: withToolResultArchiveParam({
+            __activeConversationId: conversationId,
+            __ownerId: conversation.ownerId
+          }, conversation),
+          messages: historyMessages,
+          abortSignal: abortController.signal
+        },
+        initialContextTokens: conversation.contextTokens ?? 0,
+        initialContextWindow: conversation.contextWindow ?? 0,
+        onEvent: (event) => {
+          if (event.type === "run:started") {
+            const active = activeConversationRuns.get(conversationId);
+            if (active) active.runId = event.runId;
           }
+          broadcastEvent(conversationId, event);
         }
-        broadcastEvent(conversationId, event);
-      }
-      if (currentTools.length > 0) sections.push({ type: "tools", content: currentTools });
-      if (currentText.length > 0) sections.push({ type: "text", content: currentText });
-      if (runContinuationMessages || assistantResponse.length > 0 || toolTimeline.length > 0) {
+      });
+      flushTurnDraft(execution.draft);
+      const callbackNeedsContinuation = execution.runContinuation && execution.runContinuationMessages;
+      if (callbackNeedsContinuation || execution.draft.assistantResponse.length > 0 || execution.draft.toolTimeline.length > 0) {
         const freshConv = await conversationStore.get(conversationId);
         if (freshConv) {
-          if (runContinuationMessages) {
-            freshConv._continuationMessages = runContinuationMessages;
+          if (callbackNeedsContinuation) {
+            freshConv._continuationMessages = execution.runContinuationMessages;
           } else {
             freshConv._continuationMessages = void 0;
             freshConv.messages.push({
               role: "assistant",
-              content: assistantResponse,
-              metadata: toolTimeline.length > 0 || sections.length > 0 ? { toolActivity: toolTimeline, sections: sections.length > 0 ? sections : void 0 } : void 0
+              content: execution.draft.assistantResponse,
+              metadata: buildAssistantMetadata(execution.draft)
             });
           }
-          if (runHarnessMessages) {
-            freshConv._harnessMessages = runHarnessMessages;
+          if (callbackNeedsContinuation && execution.runHarnessMessages) {
+            freshConv._harnessMessages = execution.runHarnessMessages;
+          } else if (historySelection.shouldRebuildCanonical) {
+            freshConv._harnessMessages = freshConv.messages;
+          } else {
+            freshConv._harnessMessages = freshConv.messages;
           }
           freshConv._toolResultArchive = harness.getToolResultArchive(conversationId);
-          freshConv.runtimeRunId = latestRunId || freshConv.runtimeRunId;
+          freshConv.runtimeRunId = execution.latestRunId || freshConv.runtimeRunId;
           freshConv.runningCallbackSince = void 0;
           freshConv.runStatus = "idle";
-          if (runContextTokens > 0) freshConv.contextTokens = runContextTokens;
-          if (runContextWindow > 0) freshConv.contextWindow = runContextWindow;
+          if (execution.runContextTokens > 0) freshConv.contextTokens = execution.runContextTokens;
+          if (execution.runContextWindow > 0) freshConv.contextWindow = execution.runContextWindow;
           freshConv.updatedAt = Date.now();
           await conversationStore.update(freshConv);
-          if (freshConv.channelMeta && assistantResponse.length > 0) {
+          if (freshConv.channelMeta && execution.draft.assistantResponse.length > 0) {
             const adapter = messagingAdapters.get(freshConv.channelMeta.platform);
             if (adapter) {
               try {
@@ -9332,7 +9625,7 @@ ${resultBody}`,
                     channelId: freshConv.channelMeta.channelId,
                     platformThreadId: freshConv.channelMeta.platformThreadId
                   },
-                  assistantResponse
+                  execution.draft.assistantResponse
                 );
               } catch (sendErr) {
                 console.error(`[poncho][subagent-callback] Messaging notify failed:`, sendErr instanceof Error ? sendErr.message : sendErr);
@@ -9341,7 +9634,7 @@ ${resultBody}`,
           }
         }
       }
-      if (runContinuation2) {
+      if (execution.runContinuation) {
         if (isServerless) {
           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)
@@ -9363,10 +9656,15 @@ ${resultBody}`,
       }
     } finally {
       activeConversationRuns.delete(conversationId);
-      finishConversationStream(conversationId);
       const hadDeferredTrigger = pendingCallbackNeeded.delete(conversationId);
       const freshConv = await conversationStore.get(conversationId);
       const hasPendingInStore = !!freshConv?.pendingSubagentResults?.length;
+      const hasRunningCallbackChildren = Array.from(activeSubagentRuns.values()).some(
+        (run) => run.parentConversationId === conversationId
+      );
+      if (!hadDeferredTrigger && !hasPendingInStore && !hasRunningCallbackChildren) {
+        finishConversationStream(conversationId);
+      }
       if (hadDeferredTrigger || hasPendingInStore) {
         if (isServerless) {
           selfFetchWithRetry(`/api/internal/conversations/${encodeURIComponent(conversationId)}/subagent-callback`).catch(
@@ -9514,8 +9812,9 @@ ${resultBody}`,
     let runContextTokens = conversation.contextTokens ?? 0;
     let runContextWindow = conversation.contextWindow ?? 0;
     let resumeHarnessMessages;
-    const baseMessages = checkpoint.baseMessageCount != null ? conversation.messages.slice(0, checkpoint.baseMessageCount) : [];
-    const fullCheckpointMessages = [...baseMessages, ...checkpoint.checkpointMessages];
+    const normalizedCheckpoint = normalizeApprovalCheckpoint(checkpoint, conversation.messages);
+    const baseMessages = normalizedCheckpoint.baseMessageCount != null ? conversation.messages.slice(0, normalizedCheckpoint.baseMessageCount) : [];
+    const fullCheckpointMessages = [...baseMessages, ...normalizedCheckpoint.checkpointMessages];
     let resumeToolResultMsg;
     const lastCpMsg = fullCheckpointMessages[fullCheckpointMessages.length - 1];
     if (lastCpMsg?.role === "assistant") {
@@ -9596,24 +9895,26 @@ ${resultBody}`,
         if (event.type === "tool:approval:checkpoint") {
           const conv = await conversationStore.get(conversationId);
           if (conv) {
-            conv.pendingApprovals = event.approvals.map((a) => ({
-              approvalId: a.approvalId,
+            conv.pendingApprovals = buildApprovalCheckpoints({
+              approvals: event.approvals,
               runId: latestRunId,
-              tool: a.tool,
-              toolCallId: a.toolCallId,
-              input: a.input,
               checkpointMessages: [...fullCheckpointWithResults, ...event.checkpointMessages],
               baseMessageCount: 0,
               pendingToolCalls: event.pendingToolCalls
-            }));
+            });
             conv.updatedAt = Date.now();
             await conversationStore.update(conv);
             if (conv.channelMeta?.platform === "telegram") {
               const tgAdapter = messagingAdapters.get("telegram");
               if (tgAdapter) {
+                const messageThreadId = parseTelegramMessageThreadIdFromPlatformThreadId(
+                  conv.channelMeta.platformThreadId,
+                  conv.channelMeta.channelId
+                );
                 void tgAdapter.sendApprovalRequest(
                   conv.channelMeta.channelId,
-                  event.approvals.map((a) => ({ approvalId: a.approvalId, tool: a.tool, input: a.input }))
+                  event.approvals.map((a) => ({ approvalId: a.approvalId, tool: a.tool, input: a.input })),
+                  { message_thread_id: messageThreadId }
                 ).catch(() => {
                 });
               }
@@ -9691,6 +9992,8 @@ ${resultBody}`,
         }
         if (resumeHarnessMessages) {
           conv._harnessMessages = resumeHarnessMessages;
+        } else {
+          conv._harnessMessages = conv.messages;
         }
         conv.runtimeRunId = latestRunId || conv.runtimeRunId;
         conv.pendingApprovals = [];
@@ -9708,7 +10011,6 @@ ${resultBody}`,
         await conversationStore.update(conv);
       }
     }
-    finishConversationStream(conversationId);
     activeConversationRuns.delete(conversationId);
     if (latestRunId) {
       runOwners.delete(latestRunId);
@@ -9717,14 +10019,20 @@ ${resultBody}`,
     console.log("[resume-run] complete for", conversationId);
     const hadDeferred = pendingCallbackNeeded.delete(conversationId);
     const postConv = await conversationStore.get(conversationId);
-    if (hadDeferred || postConv?.pendingSubagentResults?.length) {
+    const needsResumeCallback = hadDeferred || !!postConv?.pendingSubagentResults?.length;
+    const hasRunningResumeChildren = Array.from(activeSubagentRuns.values()).some(
+      (run) => run.parentConversationId === conversationId
+    );
+    if (!needsResumeCallback && !hasRunningResumeChildren) {
+      finishConversationStream(conversationId);
+    }
+    if (needsResumeCallback) {
       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 messagingRunQueues = /* @__PURE__ */ new Map();
   const messagingRouteRegistrar = (method, path, routeHandler) => {
     let byMethod = messagingRoutes.get(path);
     if (!byMethod) {
@@ -9745,7 +10053,7 @@ ${resultBody}`,
           };
           await conversationStore.update(existing);
         }
-        return { messages: existing._harnessMessages?.length ? existing._harnessMessages : existing.messages };
+        return { messages: loadCanonicalHistory(existing).messages };
       }
       const now = Date.now();
       const channelMeta = meta.channelId ? {
@@ -9767,159 +10075,116 @@ ${resultBody}`,
       return { messages: [] };
     },
     async run(conversationId, input2) {
-      const previous = messagingRunQueues.get(conversationId) ?? Promise.resolve();
-      let releaseQueue;
-      const current = new Promise((resolve4) => {
-        releaseQueue = resolve4;
+      const latestConversation = await conversationStore.get(conversationId);
+      const canonicalHistory = latestConversation ? loadCanonicalHistory(latestConversation) : { messages: [...input2.messages], source: "messages" };
+      const shouldRebuildCanonical = canonicalHistory.source !== "harness";
+      const isContinuation = input2.task == null;
+      console.log(
+        `[messaging-runner] starting run for ${conversationId} ${isContinuation ? "(continuation)" : `task: ${input2.task.slice(0, 80)}`} history_source=${canonicalHistory.source}`
+      );
+      const historyMessages = [...canonicalHistory.messages];
+      const preRunMessages = [...canonicalHistory.messages];
+      const userContent = input2.task;
+      const updateConversation = async (patch) => {
+        const fresh = await conversationStore.get(conversationId);
+        if (!fresh) return;
+        patch(fresh);
+        fresh.updatedAt = Date.now();
+        await conversationStore.update(fresh);
+      };
+      await updateConversation((c) => {
+        if (!isContinuation) {
+          c.messages = [...historyMessages, { role: "user", content: userContent }];
+        }
+        c.runStatus = "running";
       });
-      const chained = previous.then(() => current);
-      messagingRunQueues.set(conversationId, chained);
-      await previous;
-      try {
-        const latestConversation = await conversationStore.get(conversationId);
-        const latestMessages = latestConversation ? latestConversation._harnessMessages?.length ? [...latestConversation._harnessMessages] : [...latestConversation.messages] : [...input2.messages];
-        const isContinuation = input2.task == null;
-        console.log("[messaging-runner] starting run for", conversationId, isContinuation ? "(continuation)" : `task: ${input2.task.slice(0, 80)}`);
-        const historyMessages = [...latestMessages];
-        const preRunMessages = [...latestMessages];
-        const userContent = input2.task;
-        const updateConversation = async (patch) => {
-          const fresh = await conversationStore.get(conversationId);
-          if (!fresh) return;
-          patch(fresh);
-          fresh.updatedAt = Date.now();
-          await conversationStore.update(fresh);
-        };
-        await updateConversation((c) => {
-          if (!isContinuation) {
-            c.messages = [...historyMessages, { role: "user", content: userContent }];
+      let latestRunId = "";
+      const draft = createTurnDraftState();
+      let checkpointedRun = false;
+      let runContextTokens = 0;
+      let runContextWindow = 0;
+      let runContinuation2 = false;
+      let runContinuationMessages;
+      let runSteps = 0;
+      let runMaxSteps;
+      const buildMessages = () => {
+        const draftSections = cloneSections(draft.sections);
+        if (draft.currentTools.length > 0) {
+          draftSections.push({ type: "tools", content: [...draft.currentTools] });
+        }
+        if (draft.currentText.length > 0) {
+          draftSections.push({ type: "text", content: draft.currentText });
+        }
+        const userTurn = userContent != null ? [{ role: "user", content: userContent }] : [];
+        const hasDraftContent = draft.assistantResponse.length > 0 || draft.toolTimeline.length > 0 || draftSections.length > 0;
+        if (!hasDraftContent) {
+          return [...historyMessages, ...userTurn];
+        }
+        return [
+          ...historyMessages,
+          ...userTurn,
+          {
+            role: "assistant",
+            content: draft.assistantResponse,
+            metadata: buildAssistantMetadata(draft, draftSections)
           }
-          c.runStatus = "running";
+        ];
+      };
+      const persistDraftAssistantTurn = async () => {
+        if (draft.assistantResponse.length === 0 && draft.toolTimeline.length === 0) return;
+        await updateConversation((c) => {
+          c.messages = buildMessages();
         });
-        let latestRunId = "";
-        let assistantResponse = "";
-        const toolTimeline = [];
-        const sections = [];
-        let currentTools = [];
-        let currentText = "";
-        let checkpointedRun = false;
-        let runContextTokens = 0;
-        let runContextWindow = 0;
-        let runContinuation2 = false;
-        let runContinuationMessages;
-        let runSteps = 0;
-        let runMaxSteps;
-        const buildMessages = () => {
-          const draftSections = [
-            ...sections.map((s) => ({
-              type: s.type,
-              content: Array.isArray(s.content) ? [...s.content] : s.content
-            }))
-          ];
-          if (currentTools.length > 0) {
-            draftSections.push({ type: "tools", content: [...currentTools] });
-          }
-          if (currentText.length > 0) {
-            draftSections.push({ type: "text", content: currentText });
-          }
-          const userTurn = userContent != null ? [{ role: "user", content: userContent }] : [];
-          const hasDraftContent = assistantResponse.length > 0 || toolTimeline.length > 0 || draftSections.length > 0;
-          if (!hasDraftContent) {
-            return [...historyMessages, ...userTurn];
-          }
-          return [
-            ...historyMessages,
-            ...userTurn,
-            {
-              role: "assistant",
-              content: assistantResponse,
-              metadata: toolTimeline.length > 0 || draftSections.length > 0 ? {
-                toolActivity: [...toolTimeline],
-                sections: draftSections.length > 0 ? draftSections : void 0
-              } : void 0
-            }
-          ];
-        };
-        const persistDraftAssistantTurn = async () => {
-          if (assistantResponse.length === 0 && toolTimeline.length === 0) return;
-          await updateConversation((c) => {
-            c.messages = buildMessages();
-          });
-        };
-        const runInput = {
-          task: input2.task,
-          conversationId,
-          messages: historyMessages,
-          files: input2.files,
-          parameters: {
-            ...input2.metadata ? {
-              __messaging_platform: input2.metadata.platform,
-              __messaging_sender_id: input2.metadata.sender.id,
-              __messaging_sender_name: input2.metadata.sender.name ?? "",
-              __messaging_thread_id: input2.metadata.threadId
-            } : {},
-            __activeConversationId: conversationId
-          }
-        };
-        try {
-          for await (const event of harness.runWithTelemetry(runInput)) {
+      };
+      const runInput = {
+        task: input2.task,
+        conversationId,
+        messages: historyMessages,
+        files: input2.files,
+        parameters: {
+          ...input2.metadata ? {
+            __messaging_platform: input2.metadata.platform,
+            __messaging_sender_id: input2.metadata.sender.id,
+            __messaging_sender_name: input2.metadata.sender.name ?? "",
+            __messaging_thread_id: input2.metadata.threadId
+          } : {},
+          __activeConversationId: conversationId
+        }
+      };
+      try {
+        const execution = await executeConversationTurn({
+          harness,
+          runInput,
+          onEvent: async (event, eventDraft) => {
+            draft.assistantResponse = eventDraft.assistantResponse;
+            draft.toolTimeline = eventDraft.toolTimeline;
+            draft.sections = eventDraft.sections;
+            draft.currentTools = eventDraft.currentTools;
+            draft.currentText = eventDraft.currentText;
             if (event.type === "run:started") {
               latestRunId = event.runId;
               runOwners.set(event.runId, "local-owner");
               runConversations.set(event.runId, conversationId);
             }
-            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;
-            }
-            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);
-            }
-            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 === "step:completed") {
               await persistDraftAssistantTurn();
             }
             if (event.type === "tool:approval:required") {
               const toolText = `- approval required \`${event.tool}\``;
-              toolTimeline.push(toolText);
-              currentTools.push(toolText);
+              draft.toolTimeline.push(toolText);
+              draft.currentTools.push(toolText);
               await persistDraftAssistantTurn();
             }
             if (event.type === "tool:approval:checkpoint") {
               await updateConversation((c) => {
                 c.messages = buildMessages();
-                c.pendingApprovals = event.approvals.map((a) => ({
-                  approvalId: a.approvalId,
+                c.pendingApprovals = buildApprovalCheckpoints({
+                  approvals: event.approvals,
                   runId: latestRunId,
-                  tool: a.tool,
-                  toolCallId: a.toolCallId,
-                  input: a.input,
                   checkpointMessages: event.checkpointMessages,
                   baseMessageCount: historyMessages.length,
                   pendingToolCalls: event.pendingToolCalls
-                }));
+                });
               });
               checkpointedRun = true;
               const conv = await conversationStore.get(conversationId);
@@ -9931,9 +10196,14 @@ ${resultBody}`,
                     tool: a.tool,
                     input: a.input
                   }));
+                  const messageThreadId = parseTelegramMessageThreadIdFromPlatformThreadId(
+                    conv.channelMeta.platformThreadId,
+                    conv.channelMeta.channelId
+                  );
                   void tgAdapter.sendApprovalRequest(
                     conv.channelMeta.channelId,
-                    approvals
+                    approvals,
+                    { message_thread_id: messageThreadId }
                   ).catch((err) => {
                     console.error("[messaging-runner] failed to send Telegram approval request:", err instanceof Error ? err.message : err);
                   });
@@ -9955,77 +10225,76 @@ ${resultBody}`,
                 });
               }
             }
-            if (event.type === "run:completed") {
-              if (assistantResponse.length === 0 && event.result.response) {
-                assistantResponse = event.result.response;
-              }
-              runContinuation2 = event.result.continuation === true;
-              if (event.result.continuationMessages) {
-                runContinuationMessages = event.result.continuationMessages;
-              }
-              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}]`;
-            }
             broadcastEvent(conversationId, event);
           }
-        } catch (err) {
-          console.error("[messaging-runner] run failed:", err instanceof Error ? err.message : err);
-          assistantResponse = assistantResponse || `[Error: ${err instanceof Error ? err.message : "Unknown error"}]`;
-        }
-        if (currentTools.length > 0) {
-          sections.push({ type: "tools", content: currentTools });
-          currentTools = [];
-        }
-        if (currentText.length > 0) {
-          sections.push({ type: "text", content: currentText });
-          currentText = "";
-        }
-        if (!checkpointedRun) {
-          await updateConversation((c) => {
-            if (runContinuation2 && runContinuationMessages) {
-              c._continuationMessages = runContinuationMessages;
-            } else {
-              c._continuationMessages = void 0;
-              c.messages = buildMessages();
-            }
-            if (runContinuationMessages) {
-              c._harnessMessages = runContinuationMessages;
-            }
-            c.runtimeRunId = latestRunId || c.runtimeRunId;
-            c.pendingApprovals = [];
-            c.runStatus = "idle";
-            if (runContextTokens > 0) c.contextTokens = runContextTokens;
-            if (runContextWindow > 0) c.contextWindow = runContextWindow;
-          });
-        } else {
-          await updateConversation((c) => {
-            c.runStatus = "idle";
-          });
-        }
-        finishConversationStream(conversationId);
-        if (latestRunId) {
-          runOwners.delete(latestRunId);
-          runConversations.delete(latestRunId);
-        }
-        console.log("[messaging-runner] run complete, response length:", assistantResponse.length, runContinuation2 ? "(continuation)" : "");
-        const response = assistantResponse;
-        return {
-          response,
-          continuation: runContinuation2,
-          steps: runSteps,
-          maxSteps: runMaxSteps
-        };
-      } finally {
-        releaseQueue?.();
-        if (messagingRunQueues.get(conversationId) === chained) {
-          messagingRunQueues.delete(conversationId);
-        }
+        });
+        runContinuation2 = execution.runContinuation;
+        runContinuationMessages = execution.runContinuationMessages;
+        runSteps = execution.runSteps;
+        runMaxSteps = execution.runMaxSteps;
+        runContextTokens = execution.runContextTokens;
+        runContextWindow = execution.runContextWindow;
+        latestRunId = execution.latestRunId || latestRunId;
+      } catch (err) {
+        console.error("[messaging-runner] run failed:", err instanceof Error ? err.message : err);
+        draft.assistantResponse = draft.assistantResponse || `[Error: ${err instanceof Error ? err.message : "Unknown error"}]`;
+      }
+      flushTurnDraft(draft);
+      if (!checkpointedRun) {
+        await updateConversation((c) => {
+          if (runContinuation2 && runContinuationMessages) {
+            c._continuationMessages = runContinuationMessages;
+          } else {
+            c._continuationMessages = void 0;
+            c.messages = buildMessages();
+          }
+          if (runContinuationMessages) {
+            c._harnessMessages = runContinuationMessages;
+          } else if (shouldRebuildCanonical) {
+            c._harnessMessages = c.messages;
+          } else {
+            c._harnessMessages = c.messages;
+          }
+          c.runtimeRunId = latestRunId || c.runtimeRunId;
+          c.pendingApprovals = [];
+          c.runStatus = "idle";
+          if (runContextTokens > 0) c.contextTokens = runContextTokens;
+          if (runContextWindow > 0) c.contextWindow = runContextWindow;
+        });
+      } else {
+        await updateConversation((c) => {
+          if (shouldRebuildCanonical && !c._harnessMessages?.length) {
+            c._harnessMessages = c.messages;
+          }
+          c.runStatus = "idle";
+        });
       }
+      finishConversationStream(conversationId);
+      if (latestRunId) {
+        runOwners.delete(latestRunId);
+        runConversations.delete(latestRunId);
+      }
+      console.log("[messaging-runner] run complete, response length:", draft.assistantResponse.length, runContinuation2 ? "(continuation)" : "");
+      const response = draft.assistantResponse;
+      return {
+        response,
+        continuation: runContinuation2,
+        steps: runSteps,
+        maxSteps: runMaxSteps
+      };
+    },
+    async resetConversation(conversationId) {
+      const existing = await conversationStore.get(conversationId);
+      if (!existing) return;
+      existing.messages = [];
+      existing._harnessMessages = void 0;
+      existing._continuationMessages = void 0;
+      existing._toolResultArchive = void 0;
+      existing.pendingApprovals = void 0;
+      existing.runStatus = void 0;
+      existing.updatedAt = Date.now();
+      await conversationStore.update(existing);
+      console.log(`[messaging-runner] conversation reset: ${conversationId}`);
     }
   };
   let waitUntilHook;
@@ -10152,6 +10421,7 @@ ${resultBody}`,
   async function* runContinuation(conversationId) {
     const conversation = await conversationStore.get(conversationId);
     if (!conversation) return;
+    if (Array.isArray(conversation.pendingApprovals) && conversation.pendingApprovals.length > 0) return;
     if (!conversation._continuationMessages?.length) return;
     if (conversation.runStatus === "running") return;
     const count = (conversation._continuationCount ?? 0) + 1;
@@ -10300,7 +10570,11 @@ ${resultBody}`,
       freshConv._continuationMessages = void 0;
       freshConv._continuationCount = void 0;
     }
-    if (nextHarnessMessages) freshConv._harnessMessages = nextHarnessMessages;
+    if (nextHarnessMessages) {
+      freshConv._harnessMessages = nextHarnessMessages;
+    } else {
+      freshConv._harnessMessages = freshConv.messages;
+    }
     freshConv._toolResultArchive = harness.getToolResultArchive(conversationId);
     freshConv.runtimeRunId = latestRunId || freshConv.runtimeRunId;
     freshConv.pendingApprovals = [];
@@ -10422,6 +10696,8 @@ ${resultBody}`,
         }
         if (runResult?.continuationMessages) {
           conv._harnessMessages = runResult.continuationMessages;
+        } else {
+          conv._harnessMessages = conv.messages;
         }
         conv._toolResultArchive = childHarness.getToolResultArchive(conversationId);
         conv.lastActivityAt = Date.now();
@@ -10614,29 +10890,23 @@ ${resultBody}`,
             }
             return;
           }
-          const conversations = await conversationStore.list("local-owner");
-          let foundConversation;
-          let foundApproval;
-          for (const conv of conversations) {
-            if (!Array.isArray(conv.pendingApprovals)) continue;
-            const match = conv.pendingApprovals.find((a) => a.approvalId === approvalId);
-            if (match) {
-              foundConversation = conv;
-              foundApproval = match;
-              break;
-            }
-          }
+          const found = await findPendingApproval(approvalId, "local-owner");
+          let foundConversation = found?.conversation;
+          let foundApproval = found?.approval;
           if (!foundConversation || !foundApproval) {
             console.warn("[telegram-approval] approval not found:", approvalId);
             return;
           }
+          foundApproval = normalizeApprovalCheckpoint(foundApproval, foundConversation.messages);
           await adapter.updateApprovalMessage(approvalId, approved ? "approved" : "denied", foundApproval.tool);
           foundApproval.decision = approved ? "approved" : "denied";
           broadcastEvent(
             foundConversation.conversationId,
             approved ? { type: "tool:approval:granted", approvalId } : { type: "tool:approval:denied", approvalId }
           );
-          const allApprovals = foundConversation.pendingApprovals ?? [];
+          const allApprovals = (foundConversation.pendingApprovals ?? []).map(
+            (approval) => normalizeApprovalCheckpoint(approval, foundConversation.messages)
+          );
           const allDecided = allApprovals.length > 0 && allApprovals.every((a) => a.decision != null);
           if (!allDecided) {
             await conversationStore.update(foundConversation);
@@ -10985,6 +11255,9 @@ ${resultBody}`,
         return;
       }
       if (requireAuth && session && !hasBearerToken && requiresCsrfValidation && pathname !== "/api/auth/login" && request.headers["x-csrf-token"] !== session?.csrfToken) {
+        console.warn(
+          `[poncho][csrf] blocked request method=${request.method} path="${pathname}" session=${session.sessionId}`
+        );
         writeJson(response, 403, {
           code: "CSRF_ERROR",
           message: "Invalid CSRF token"
@@ -11180,6 +11453,7 @@ data: ${JSON.stringify(frame)}
       const approvalId = decodeURIComponent(approvalMatch[1] ?? "");
       const body = await readRequestBody(request);
       const approved = body.approved === true;
+      const hintedConversationId = typeof body.conversationId === "string" && body.conversationId.trim().length > 0 ? body.conversationId.trim() : void 0;
       const pendingSubagent = pendingSubagentApprovals.get(approvalId);
       if (pendingSubagent) {
         pendingSubagent.checkpoint.decision = approved ? "approved" : "denied";
@@ -11205,18 +11479,23 @@ data: ${JSON.stringify(frame)}
         writeJson(response, 200, { ok: true, approvalId, approved });
         return;
       }
-      const conversations = await conversationStore.list(ownerId);
       let foundConversation;
       let foundApproval;
-      for (const conv of conversations) {
-        if (!Array.isArray(conv.pendingApprovals)) continue;
-        const match = conv.pendingApprovals.find((a) => a.approvalId === approvalId);
-        if (match) {
-          foundConversation = conv;
-          foundApproval = match;
-          break;
+      if (hintedConversationId) {
+        const hintedConversation = await conversationStore.get(hintedConversationId);
+        if (hintedConversation && hintedConversation.ownerId === ownerId && Array.isArray(hintedConversation.pendingApprovals)) {
+          const hintedMatch = hintedConversation.pendingApprovals.find((approval) => approval.approvalId === approvalId);
+          if (hintedMatch) {
+            foundConversation = hintedConversation;
+            foundApproval = hintedMatch;
+          }
         }
       }
+      if (!foundConversation || !foundApproval) {
+        const found = await findPendingApproval(approvalId, ownerId);
+        foundConversation = found?.conversation;
+        foundApproval = found?.approval;
+      }
       if (!foundConversation || !foundApproval) {
         writeJson(response, 404, {
           code: "APPROVAL_NOT_FOUND",
@@ -11225,37 +11504,32 @@ data: ${JSON.stringify(frame)}
         return;
       }
       const conversationId = foundConversation.conversationId;
+      foundApproval = normalizeApprovalCheckpoint(foundApproval, foundConversation.messages);
       if (!foundApproval.checkpointMessages || !foundApproval.toolCallId) {
-        foundConversation.pendingApprovals = (foundConversation.pendingApprovals ?? []).filter((a) => a.approvalId !== approvalId);
-        await conversationStore.update(foundConversation);
-        writeJson(response, 404, {
-          code: "APPROVAL_NOT_FOUND",
-          message: "Approval request is no longer active (no checkpoint data)"
+        writeJson(response, 409, {
+          code: "APPROVAL_NOT_READY",
+          message: "Approval checkpoint is not ready yet. Please retry shortly."
         });
         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";
+      const approvalDecision = approved ? "approved" : "denied";
+      foundConversation.pendingApprovals = (foundConversation.pendingApprovals ?? []).map(
+        (approval) => approval.approvalId === approvalId ? { ...normalizeApprovalCheckpoint(approval, foundConversation.messages), decision: approvalDecision } : normalizeApprovalCheckpoint(approval, foundConversation.messages)
+      );
+      await conversationStore.update(foundConversation);
       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) => batchDecisions.has(a.approvalId));
+      const refreshedConversation = await conversationStore.get(conversationId);
+      const allApprovals = (refreshedConversation?.pendingApprovals ?? []).map(
+        (approval) => normalizeApprovalCheckpoint(approval, refreshedConversation.messages)
+      );
+      const allDecided = allApprovals.length > 0 && allApprovals.every((a) => a.decision != null);
       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";
@@ -11460,7 +11734,8 @@ data: ${JSON.stringify(frame)}
           approvalId: a.approvalId,
           runId: a.runId,
           tool: a.tool,
-          input: a.input
+          input: a.input,
+          decision: a.decision
         })) : [];
         const subagentPending = [];
         if (!conversation.parentConversationId) {
@@ -11477,22 +11752,10 @@ data: ${JSON.stringify(frame)}
         }
         const activeStream = conversationEventStreams.get(conversationId);
         const hasActiveRun = !!activeStream && !activeStream.finished || conversation.runStatus === "running";
-        let hasRunningSubagents = Array.from(activeSubagentRuns.values()).some(
-          (r) => r.parentConversationId === conversationId
-        );
-        if (!hasRunningSubagents && !conversation.parentConversationId) {
-          const summaries = await conversationStore.listSummaries(conversation.ownerId);
-          for (const s of summaries) {
-            if (s.parentConversationId !== conversationId) continue;
-            const c = await conversationStore.get(s.conversationId);
-            if (c?.subagentMeta?.status === "running") {
-              hasRunningSubagents = true;
-              break;
-            }
-          }
-        }
+        const hasRunningSubagents = !conversation.parentConversationId ? await hasRunningSubagentsForParent(conversationId, conversation.ownerId) : false;
         const hasPendingCallbackResults = Array.isArray(conversation.pendingSubagentResults) && conversation.pendingSubagentResults.length > 0;
-        const needsContinuation = !hasActiveRun && Array.isArray(conversation._continuationMessages) && conversation._continuationMessages.length > 0;
+        const hasPendingApprovals = Array.isArray(conversation.pendingApprovals) && conversation.pendingApprovals.length > 0;
+        const needsContinuation = !hasActiveRun && Array.isArray(conversation._continuationMessages) && conversation._continuationMessages.length > 0 && !hasPendingApprovals;
         writeJson(response, 200, {
           conversation: {
             ...conversation,
@@ -11706,11 +11969,9 @@ data: ${JSON.stringify(frame)}
           eventCount++;
           let sseEvent = event;
           if (sseEvent.type === "run:completed") {
-            const hasRunningSubagents = Array.from(activeSubagentRuns.values()).some(
-              (r) => r.parentConversationId === conversationId
-            );
+            const hasPendingSubagents = await hasPendingSubagentWorkForParent(conversationId, ownerId);
             const stripped = { ...sseEvent, result: { ...sseEvent.result, continuationMessages: void 0 } };
-            sseEvent = hasRunningSubagents ? { ...stripped, pendingSubagents: true } : stripped;
+            sseEvent = hasPendingSubagents ? { ...stripped, pendingSubagents: true } : stripped;
           }
           try {
             response.write(formatSseEvent(sseEvent));
@@ -11738,7 +11999,7 @@ data: ${JSON.stringify(frame)}
         }
       } else {
         const freshConv = await conversationStore.get(conversationId);
-        if (freshConv?._continuationMessages?.length) {
+        if (freshConv?._continuationMessages?.length && (!Array.isArray(freshConv.pendingApprovals) || freshConv.pendingApprovals.length === 0)) {
           doWaitUntil(
             new Promise((r) => setTimeout(r, 3e3)).then(
               () => selfFetchWithRetry(`/api/internal/continue/${encodeURIComponent(conversationId)}`)
@@ -11820,9 +12081,17 @@ data: ${JSON.stringify(frame)}
         Connection: "keep-alive",
         "X-Accel-Buffering": "no"
       });
-      const harnessMessages = conversation._harnessMessages?.length ? [...conversation._harnessMessages] : [...conversation.messages];
+      const canonicalHistory = resolveRunRequest(conversation, {
+        conversationId,
+        messages: conversation.messages
+      });
+      const shouldRebuildCanonical = canonicalHistory.shouldRebuildCanonical;
+      const harnessMessages = [...canonicalHistory.messages];
       const historyMessages = [...conversation.messages];
       const preRunMessages = [...conversation.messages];
+      console.info(
+        `[poncho] conversation="${conversationId}" history_source=${canonicalHistory.source}`
+      );
       let latestRunId = conversation.runtimeRunId ?? "";
       let assistantResponse = "";
       const toolTimeline = [];
@@ -12017,6 +12286,24 @@ data: ${JSON.stringify(frame)}
             const toolText = `- approval required \`${event.tool}\``;
             toolTimeline.push(toolText);
             currentTools.push(toolText);
+            const existingApprovals = Array.isArray(conversation.pendingApprovals) ? conversation.pendingApprovals : [];
+            if (!existingApprovals.some((approval) => approval.approvalId === event.approvalId)) {
+              conversation.pendingApprovals = [
+                ...existingApprovals,
+                {
+                  approvalId: event.approvalId,
+                  runId: latestRunId || conversation.runtimeRunId || "",
+                  tool: event.tool,
+                  toolCallId: void 0,
+                  input: event.input ?? {},
+                  checkpointMessages: void 0,
+                  baseMessageCount: historyMessages.length,
+                  pendingToolCalls: []
+                }
+              ];
+              conversation.updatedAt = Date.now();
+              await conversationStore.update(conversation);
+            }
             await persistDraftAssistantTurn();
           }
           if (event.type === "tool:approval:checkpoint") {
@@ -12036,16 +12323,13 @@ data: ${JSON.stringify(frame)}
                 metadata: toolTimeline.length > 0 || checkpointSections.length > 0 ? { toolActivity: [...toolTimeline], sections: checkpointSections.length > 0 ? checkpointSections : void 0 } : void 0
               }] : []
             ];
-            conversation.pendingApprovals = event.approvals.map((a) => ({
-              approvalId: a.approvalId,
+            conversation.pendingApprovals = buildApprovalCheckpoints({
+              approvals: event.approvals,
               runId: latestRunId,
-              tool: a.tool,
-              toolCallId: a.toolCallId,
-              input: a.input,
               checkpointMessages: event.checkpointMessages,
               baseMessageCount: historyMessages.length,
               pendingToolCalls: event.pendingToolCalls
-            }));
+            });
             conversation._toolResultArchive = harness.getToolResultArchive(conversationId);
             conversation.updatedAt = Date.now();
             await conversationStore.update(conversation);
@@ -12076,26 +12360,28 @@ data: ${JSON.stringify(frame)}
               conversation._harnessMessages = runContinuationMessages;
               conversation._toolResultArchive = harness.getToolResultArchive(conversationId);
               conversation.runtimeRunId = latestRunId || conversation.runtimeRunId;
-              conversation.pendingApprovals = [];
+              if (!checkpointedRun) {
+                conversation.pendingApprovals = [];
+              }
               if (runContextTokens > 0) conversation.contextTokens = runContextTokens;
               if (runContextWindow > 0) conversation.contextWindow = runContextWindow;
               conversation.updatedAt = Date.now();
               await conversationStore.update(conversation);
-              doWaitUntil(
-                new Promise((r) => setTimeout(r, 3e3)).then(
-                  () => selfFetchWithRetry(`/api/internal/continue/${encodeURIComponent(conversationId)}`)
-                )
-              );
+              if (!checkpointedRun) {
+                doWaitUntil(
+                  new Promise((r) => setTimeout(r, 3e3)).then(
+                    () => selfFetchWithRetry(`/api/internal/continue/${encodeURIComponent(conversationId)}`)
+                  )
+                );
+              }
             }
           }
           await telemetry.emit(event);
           let sseEvent = event.type === "compaction:completed" && event.compactedMessages ? { ...event, compactedMessages: void 0 } : event;
           if (sseEvent.type === "run:completed") {
-            const hasRunningSubagents = Array.from(activeSubagentRuns.values()).some(
-              (r) => r.parentConversationId === conversationId
-            );
+            const hasPendingSubagents = await hasPendingSubagentWorkForParent(conversationId, ownerId);
             const stripped = { ...sseEvent, result: { ...sseEvent.result, continuationMessages: void 0 } };
-            if (hasRunningSubagents) {
+            if (hasPendingSubagents) {
               sseEvent = { ...stripped, pendingSubagents: true };
             } else {
               sseEvent = stripped;
@@ -12132,6 +12418,10 @@ data: ${JSON.stringify(frame)}
           conversation._continuationMessages = void 0;
           if (runHarnessMessages) {
             conversation._harnessMessages = runHarnessMessages;
+          } else if (shouldRebuildCanonical) {
+            conversation._harnessMessages = conversation.messages;
+          } else {
+            conversation._harnessMessages = conversation.messages;
           }
           conversation._toolResultArchive = harness.getToolResultArchive(conversationId);
           conversation.runtimeRunId = latestRunId || conversation.runtimeRunId;
@@ -12166,7 +12456,9 @@ data: ${JSON.stringify(frame)}
             conversation.updatedAt = Date.now();
             await conversationStore.update(conversation);
           }
-          await clearPendingApprovalsForConversation(conversationId);
+          if (!checkpointedRun) {
+            await clearPendingApprovalsForConversation(conversationId);
+          }
           return;
         }
         try {
@@ -12211,18 +12503,24 @@ data: ${JSON.stringify(frame)}
         if (active && active.abortController === abortController) {
           activeConversationRuns.delete(conversationId);
         }
-        finishConversationStream(conversationId);
         if (latestRunId) {
           runOwners.delete(latestRunId);
           runConversations.delete(latestRunId);
         }
+        const hadDeferred = pendingCallbackNeeded.delete(conversationId);
+        const freshConv = await conversationStore.get(conversationId);
+        const needsCallback = hadDeferred || !!freshConv?.pendingSubagentResults?.length;
+        const hasRunningChildren = Array.from(activeSubagentRuns.values()).some(
+          (run) => run.parentConversationId === conversationId
+        );
+        if (!needsCallback && !hasRunningChildren) {
+          finishConversationStream(conversationId);
+        }
         try {
           response.end();
         } catch {
         }
-        const hadDeferred = pendingCallbackNeeded.delete(conversationId);
-        const freshConv = await conversationStore.get(conversationId);
-        if (hadDeferred || freshConv?.pendingSubagentResults?.length) {
+        if (needsCallback) {
           processSubagentCallback(conversationId, true).catch(
             (err) => console.error(`[poncho][subagent-callback] Post-run callback failed:`, err instanceof Error ? err.message : err)
           );
@@ -12279,43 +12577,41 @@ data: ${JSON.stringify(frame)}
             if (!conv) continue;
             const task = `[Scheduled: ${jobName}]
 ${cronJob.task}`;
-            const historyMessages = conv._harnessMessages?.length ? [...conv._harnessMessages] : [...conv.messages];
+            const historySelection = resolveRunRequest(conv, {
+              conversationId: conv.conversationId,
+              messages: conv.messages
+            });
+            const historyMessages = [...historySelection.messages];
             try {
-              let assistantResponse = "";
-              let steps = 0;
-              let cronHarnessMessages;
-              for await (const event of harness.runWithTelemetry({
-                task,
-                conversationId: conv.conversationId,
-                parameters: withToolResultArchiveParam(
-                  { __activeConversationId: conv.conversationId },
-                  conv
-                ),
-                messages: historyMessages
-              })) {
-                if (event.type === "model:chunk") {
-                  assistantResponse += event.content;
-                }
-                if (event.type === "run:completed") {
-                  steps = event.result.steps;
-                  if (!assistantResponse && event.result.response) {
-                    assistantResponse = event.result.response;
-                  }
-                  if (event.result.continuationMessages) {
-                    cronHarnessMessages = event.result.continuationMessages;
-                  }
+              const execution = await executeConversationTurn({
+                harness,
+                runInput: {
+                  task,
+                  conversationId: conv.conversationId,
+                  parameters: withToolResultArchiveParam(
+                    { __activeConversationId: conv.conversationId },
+                    conv
+                  ),
+                  messages: historyMessages
+                },
+                onEvent: async (event) => {
+                  await telemetry.emit(event);
                 }
-                await telemetry.emit(event);
-              }
+              });
+              const assistantResponse = execution.draft.assistantResponse;
               conv.messages = [
                 ...historyMessages,
                 { role: "user", content: task },
                 ...assistantResponse ? [{ role: "assistant", content: assistantResponse }] : []
               ];
-              if (cronHarnessMessages) {
-                conv._harnessMessages = cronHarnessMessages;
+              if (execution.runHarnessMessages) {
+                conv._harnessMessages = execution.runHarnessMessages;
+              } else if (historySelection.shouldRebuildCanonical) {
+                conv._harnessMessages = conv.messages;
               }
               conv._toolResultArchive = harness.getToolResultArchive(conv.conversationId);
+              if (execution.runContextTokens > 0) conv.contextTokens = execution.runContextTokens;
+              if (execution.runContextWindow > 0) conv.contextWindow = execution.runContextWindow;
               conv.updatedAt = Date.now();
               await conversationStore.update(conv);
               if (assistantResponse) {
@@ -12331,7 +12627,7 @@ ${cronJob.task}`;
                   console.error(`[cron] ${jobName}: send to ${chatId} failed:`, sendError instanceof Error ? sendError.message : sendError);
                 }
               }
-              chatResults.push({ chatId, status: "completed", steps });
+              chatResults.push({ chatId, status: "completed", steps: execution.runSteps });
             } catch (runError) {
               chatResults.push({ chatId, status: "error" });
               console.error(`[cron] ${jobName}: run for chat ${chatId} failed:`, runError instanceof Error ? runError.message : runError);
@@ -12580,86 +12876,30 @@ var startDevServer = async (port, options) => {
   const { Cron } = await import("croner");
   let activeJobs = [];
   const runCronAgent = async (harnessRef, task, conversationId, historyMessages, toolResultArchive, onEvent) => {
-    let assistantResponse = "";
-    let steps = 0;
-    let contextTokens = 0;
-    let contextWindow = 0;
-    let harnessMessages;
-    const toolTimeline = [];
-    const sections = [];
-    let currentTools = [];
-    let currentText = "";
-    for await (const event of harnessRef.runWithTelemetry({
-      task,
-      conversationId,
-      parameters: {
-        __activeConversationId: conversationId,
-        [TOOL_RESULT_ARCHIVE_PARAM]: toolResultArchive ?? {}
+    const execution = await executeConversationTurn({
+      harness: harnessRef,
+      runInput: {
+        task,
+        conversationId,
+        parameters: {
+          __activeConversationId: conversationId,
+          [TOOL_RESULT_ARCHIVE_PARAM]: toolResultArchive ?? {}
+        },
+        messages: historyMessages
       },
-      messages: historyMessages
-    })) {
-      onEvent?.(event);
-      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;
-      }
-      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);
-      }
-      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") {
-        steps = event.result.steps;
-        contextTokens = event.result.contextTokens ?? 0;
-        contextWindow = event.result.contextWindow ?? 0;
-        if (event.result.continuationMessages) {
-          harnessMessages = event.result.continuationMessages;
-        }
-        if (!assistantResponse && event.result.response) {
-          assistantResponse = event.result.response;
-        }
-      }
-    }
-    if (currentTools.length > 0) {
-      sections.push({ type: "tools", content: currentTools });
-    }
-    if (currentText.length > 0) {
-      sections.push({ type: "text", content: 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;
+      onEvent
+    });
+    flushTurnDraft(execution.draft);
+    const hasContent = execution.draft.assistantResponse.length > 0 || execution.draft.toolTimeline.length > 0;
+    const assistantMetadata = buildAssistantMetadata(execution.draft);
     return {
-      response: assistantResponse,
-      steps,
+      response: execution.draft.assistantResponse,
+      steps: execution.runSteps,
       assistantMetadata,
       hasContent,
-      contextTokens,
-      contextWindow,
-      harnessMessages,
+      contextTokens: execution.runContextTokens,
+      contextWindow: execution.runContextWindow,
+      harnessMessages: execution.runHarnessMessages,
       toolResultArchive: harnessRef.getToolResultArchive(conversationId)
     };
   };
@@ -12720,7 +12960,11 @@ var startDevServer = async (port, options) => {
                 if (!conversation) continue;
                 const task = `[Scheduled: ${jobName}]
 ${config.task}`;
-                const historyMessages = conversation._harnessMessages?.length ? [...conversation._harnessMessages] : [...conversation.messages];
+                const historySelection = resolveRunRequest(conversation, {
+                  conversationId: conversation.conversationId,
+                  messages: conversation.messages
+                });
+                const historyMessages = [...historySelection.messages];
                 const convId = conversation.conversationId;
                 activeRuns?.set(convId, {
                   ownerId: "local-owner",
@@ -12743,6 +12987,8 @@ ${config.task}`;
                     freshConv.messages = buildCronMessages(task, historyMessages, result);
                     if (result.harnessMessages) {
                       freshConv._harnessMessages = result.harnessMessages;
+                    } else if (historySelection.shouldRebuildCanonical) {
+                      freshConv._harnessMessages = freshConv.messages;
                     }
                     if (result.toolResultArchive) {
                       freshConv._toolResultArchive = result.toolResultArchive;
@@ -12960,7 +13206,7 @@ var runInteractive = async (workingDir, params) => {
   await harness.initialize();
   const identity = await ensureAgentIdentity2(workingDir);
   try {
-    const { runInteractiveInk } = await import("./run-interactive-ink-GPCI4L6G.js");
+    const { runInteractiveInk } = await import("./run-interactive-ink-LAL4PQVD.js");
     await runInteractiveInk({
       harness,
       params,
@@ -13694,6 +13940,7 @@ export {
   inferConversationTitle,
   consumeFirstRunIntro,
   resolveHarnessEnvironment,
+  __internalRunOrchestration,
   initProject,
   updateAgentGuidance,
   createRequestHandler,