@rtrvr-ai/rover 1.1.2 → 1.2.1

package/dist/worker/rover-worker.js

@@ -758,13 +758,13 @@ function isAllowedByRules(url, rules) {
   if (!host)
     return { allowed: false, reason: "invalid_url" };
   if (rules.denyDomains.some((rule) => matchesDomainRule(host, rule))) {
-    return { allowed: false, reason: `deny_rule:${host}` };
+    return { allowed: false, reason: "deny_rule" };
   }
   if (!rules.allowDomains.length)
     return { allowed: true };
   if (rules.allowDomains.some((rule) => matchesDomainRule(host, rule)))
     return { allowed: true };
-  return { allowed: false, reason: `not_in_allowlist:${host}` };
+  return { allowed: false, reason: "not_in_allowlist" };
 }
 function normalizeRuntimeExternalTabs(input) {
   if (!Array.isArray(input))
@@ -1456,6 +1456,61 @@ async function processActionResponse({ request, response, tabId, prevSteps, thou
     return { needsRetry: false, data };
   }
   if (Array.isArray(functionCalls) && functionCalls.length > 0) {
+    const askUserCall = functionCalls.find((call) => String(call?.name || "").trim().toLowerCase() === "ask_user");
+    if (askUserCall) {
+      const questions = normalizeAskUserQuestions(askUserCall?.args?.questions_to_ask);
+      if (!questions.length) {
+        prevSteps.push({
+          accTreeId,
+          thought,
+          modelParts,
+          fail: "ask_user called with invalid or empty 'questions_to_ask'",
+          functions: [
+            {
+              name: "ask_user",
+              args: askUserCall?.args || {},
+              response: {
+                status: "Failure",
+                error: "Missing/invalid 'questions_to_ask'",
+                allowFallback: false
+              }
+            }
+          ]
+        });
+        limitPrevSteps(prevSteps);
+        onPrevStepsUpdate?.(prevSteps);
+        return { needsRetry: true };
+      }
+      prevSteps.push({
+        accTreeId,
+        thought,
+        modelParts,
+        functions: [
+          {
+            name: "ask_user",
+            args: {
+              questions_to_ask: questions.map((question) => ({ key: question.key, query: question.query }))
+            },
+            response: {
+              status: "Success",
+              output: {
+                status: "waiting_input",
+                needsUserInput: true,
+                questions
+              }
+            }
+          }
+        ]
+      });
+      limitPrevSteps(prevSteps);
+      onPrevStepsUpdate?.(prevSteps);
+      onStatusUpdate?.("Need user clarification to continue", thought, "verify");
+      return {
+        needsRetry: false,
+        needsUserInput: true,
+        questions
+      };
+    }
     const systemCalls = [];
     const externalCalls = [];
     for (const call of functionCalls) {
@@ -1538,6 +1593,39 @@ async function processActionResponse({ request, response, tabId, prevSteps, thou
   onPrevStepsUpdate?.(prevSteps);
   return { needsRetry: true };
 }
+function normalizeAskUserQuestions(rawQuestions) {
+  if (!Array.isArray(rawQuestions))
+    return [];
+  const out = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const item of rawQuestions) {
+    if (!item || typeof item !== "object")
+      continue;
+    const rawKey = String(item.key || "").trim();
+    const query = resolveQuestionText(item);
+    if (!rawKey || !query)
+      continue;
+    if (seenKeys.has(rawKey))
+      continue;
+    seenKeys.add(rawKey);
+    out.push({
+      key: rawKey,
+      query,
+      ...typeof item.question === "string" && item.question.trim() ? { question: String(item.question).trim() } : {},
+      ...typeof item.id === "string" && item.id.trim() ? { id: String(item.id).trim() } : {},
+      ...Array.isArray(item.choices) ? { choices: item.choices } : {}
+    });
+  }
+  return out.slice(0, 6);
+}
+function resolveQuestionText(raw) {
+  if (!raw || typeof raw !== "object")
+    return "";
+  const question = String(raw.query || raw.question || "").trim();
+  if (!question)
+    return "";
+  return question;
+}
 function limitPrevSteps(prevSteps) {
   if (prevSteps.length <= MAX_PREV_STEPS)
     return;
@@ -1838,6 +1926,17 @@ async function executeAgenticSeek(options) {
           warnings: allWarnings
         };
       }
+      if (processResult.needsUserInput && Array.isArray(processResult.questions) && processResult.questions.length > 0) {
+        managePrevStepsSize(accumulatedPrevSteps);
+        onPrevStepsUpdate?.(accumulatedPrevSteps);
+        return {
+          prevSteps: accumulatedPrevSteps,
+          creditsUsed: totalCreditsUsed,
+          warnings: allWarnings,
+          needsUserInput: true,
+          questions: processResult.questions
+        };
+      }
       if (processResult.functionCalls?.length) {
         const functionCallsWithIds = processResult.functionCalls.map((fc, index) => ({
           ...fc,
@@ -2592,8 +2691,7 @@ function resolvePath(obj, path) {
 }
 
 // dist/agent/toolExecutor.js
-var MAX_AGENT_CHATLOG_ENTRIES = 24;
-var MAX_AGENT_CHATLOG_MESSAGE_CHARS = 1e3;
+var MAX_AGENT_CHATLOG_ENTRIES = 12;
 function unsupportedToolResult(toolName, message) {
   return {
     error: message,
@@ -2624,17 +2722,31 @@ function buildStructuredErrorOutput(envelope) {
 function normalizeAgentLog(agentLog) {
   const prevSteps = Array.isArray(agentLog?.prevSteps) ? agentLog.prevSteps : [];
   const sanitizeMessage = (value) => {
-    const normalized = String(value || "").replace(/\s+/g, " ").trim();
-    if (!normalized)
-      return "";
-    if (normalized.length <= MAX_AGENT_CHATLOG_MESSAGE_CHARS)
-      return normalized;
-    return `${normalized.slice(0, MAX_AGENT_CHATLOG_MESSAGE_CHARS - 1)}\u2026`;
+    return String(value || "").replace(/\s+/g, " ").trim();
   };
-  const chatLog = Array.isArray(agentLog?.chatLog) ? agentLog.chatLog.map((entry) => ({
+  const normalizedChatLog = Array.isArray(agentLog?.chatLog) ? agentLog.chatLog.map((entry) => ({
     role: entry?.role === "user" ? "user" : "model",
     message: typeof entry?.message === "string" ? sanitizeMessage(entry.message) : ""
-  })).filter((entry) => !!entry.message).slice(-MAX_AGENT_CHATLOG_ENTRIES) : [];
+  })).filter((entry) => !!entry.message) : [];
+  const dedupedChatLog = [];
+  for (const entry of normalizedChatLog) {
+    const previous = dedupedChatLog[dedupedChatLog.length - 1];
+    if (previous && previous.role === entry.role && previous.message === entry.message)
+      continue;
+    dedupedChatLog.push(entry);
+  }
+  const firstUser = dedupedChatLog.find((entry) => entry.role === "user");
+  const tailBudget = firstUser ? Math.max(1, MAX_AGENT_CHATLOG_ENTRIES - 1) : MAX_AGENT_CHATLOG_ENTRIES;
+  let chatLog = dedupedChatLog.slice(-tailBudget);
+  if (firstUser) {
+    const hasAnchor = chatLog.some((entry) => entry.role === "user" && entry.message === firstUser.message);
+    if (!hasAnchor) {
+      chatLog = [firstUser, ...chatLog];
+    }
+  }
+  if (chatLog.length > MAX_AGENT_CHATLOG_ENTRIES) {
+    chatLog = chatLog.slice(-MAX_AGENT_CHATLOG_ENTRIES);
+  }
   return { prevSteps, chatLog };
 }
 async function executeToolFromPlan(context) {
@@ -2667,7 +2779,12 @@ async function executeToolFromPlan(context) {
           ctx: effectiveCtx,
           onPrevStepsUpdate
         });
-        return { ...actResult, output: actResult.data };
+        const actOutput = actResult.data ?? (actResult.needsUserInput ? {
+          status: "waiting_input",
+          needsUserInput: true,
+          questions: Array.isArray(actResult.questions) ? actResult.questions : []
+        } : void 0);
+        return { ...actResult, output: actOutput };
       }
       case PLANNER_FUNCTION_CALLS.EXTRACT: {
         const prompt = toolArgs?.user_input || toolArgs?.prompt || toolArgs?.task_instruction || userInput;
@@ -3452,18 +3569,34 @@ async function executeCustomToolGenerator({ userInput, plannerPrevSteps, files,
 
 // dist/agent/plannerAgent.js
 var MAX_PLANNER_DEPTH = 15;
-var MAX_CHATLOG_ENTRIES = 24;
-var MAX_CHATLOG_MESSAGE_CHARS = 1e3;
+var MAX_CHATLOG_ENTRIES = 12;
 function normalizeChatLog(entries) {
   if (!Array.isArray(entries) || !entries.length)
     return [];
-  return entries.map((entry) => ({
+  const normalized = entries.map((entry) => ({
     role: entry?.role === "user" ? "user" : "model",
     message: String(entry?.message || "").replace(/\s+/g, " ").trim()
-  })).filter((entry) => !!entry.message).map((entry) => ({
-    role: entry.role,
-    message: entry.message.length > MAX_CHATLOG_MESSAGE_CHARS ? `${entry.message.slice(0, MAX_CHATLOG_MESSAGE_CHARS - 1)}\u2026` : entry.message
-  })).slice(-MAX_CHATLOG_ENTRIES);
+  })).filter((entry) => !!entry.message);
+  const deduped = [];
+  for (const entry of normalized) {
+    const previous = deduped[deduped.length - 1];
+    if (previous && previous.role === entry.role && previous.message === entry.message)
+      continue;
+    deduped.push(entry);
+  }
+  const firstUser = deduped.find((entry) => entry.role === "user");
+  const tailBudget = firstUser ? Math.max(1, MAX_CHATLOG_ENTRIES - 1) : MAX_CHATLOG_ENTRIES;
+  let selected = deduped.slice(-tailBudget);
+  if (firstUser) {
+    const hasAnchor = selected.some((entry) => entry.role === "user" && entry.message === firstUser.message);
+    if (!hasAnchor) {
+      selected = [firstUser, ...selected];
+    }
+  }
+  if (selected.length > MAX_CHATLOG_ENTRIES) {
+    selected = selected.slice(-MAX_CHATLOG_ENTRIES);
+  }
+  return selected;
 }
 async function executePlanner(options) {
   const { userInput, tabs, previousMessages = [], trajectoryId: trajectoryId2, previousSteps = [], files, continuePlanning = false, recordingContext, driveAuthToken, agentLog, lastToolPreviousSteps, ctx, bridgeRpc: bridgeRpc2, functionDeclarations } = options;
@@ -4163,20 +4296,19 @@ var bridgeRpc = null;
 var toolRegistry = new ToolRegistry();
 var plannerHistory = [];
 var agentPrevSteps = [];
+var pendingAskUser;
 var trajectoryId = crypto.randomUUID();
 var tabularStore = null;
 var PLANNER_TOOL_NAME_SET = new Set(Object.values(PLANNER_FUNCTION_CALLS));
 var activeRun = null;
-var cancelledRunId = null;
+var cancelledRunIds = /* @__PURE__ */ new Set();
 var activeAbortController = null;
 var lastStatusKey = "";
 var seenStatusKeys = /* @__PURE__ */ new Set();
-var completedRunIds = /* @__PURE__ */ new Set();
-var completedRunOutcomes = /* @__PURE__ */ new Map();
+var terminalRuns = /* @__PURE__ */ new Map();
 var RPC_TIMEOUT_MS = 3e4;
 var DETACHED_EXTERNAL_TAB_MAX_AGE_MS = 9e4;
-var MAX_CHATLOG_ENTRIES2 = 24;
-var MAX_CHATLOG_MESSAGE_CHARS2 = 1e3;
+var MAX_CHATLOG_ENTRIES2 = 12;
 function resolveAgentName(config2) {
   const raw = String(config2?.ui?.agent?.name || "").trim();
   if (!raw)
@@ -4392,11 +4524,6 @@ function postStatus(message, thought, stage) {
   self.postMessage({ type: "status", message, thought, stage: resolvedStage, compactThought: compact, runId: activeRun?.runId });
   postStateSnapshot();
 }
-function truncateText(value, max = 8e3) {
-  if (value.length <= max)
-    return value;
-  return `${value.slice(0, max)}\u2026`;
-}
 function cloneUnknown(value) {
   if (value == null)
     return value;
@@ -4439,6 +4566,90 @@ function sanitizeAgentPrevStepsForPersist(input) {
   }
   return out;
 }
+function normalizePlannerQuestion(input, index) {
+  if (!input || typeof input !== "object")
+    return void 0;
+  const keyCandidate = String(input.key || input.id || "").trim();
+  const queryCandidate = String(input.query || input.question || "").trim();
+  const key = keyCandidate || `clarification_${index + 1}`;
+  if (!queryCandidate)
+    return void 0;
+  return {
+    key,
+    query: queryCandidate,
+    ...typeof input.id === "string" && input.id.trim() ? { id: input.id.trim() } : {},
+    ...typeof input.question === "string" && input.question.trim() ? { question: input.question.trim() } : {},
+    ...Array.isArray(input.choices) ? { choices: input.choices } : {}
+  };
+}
+function normalizePlannerQuestions(input) {
+  if (!Array.isArray(input))
+    return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < input.length; i += 1) {
+    const question = normalizePlannerQuestion(input[i], i);
+    if (!question)
+      continue;
+    const key = `${question.key}::${question.query}`.toLowerCase();
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    out.push(question);
+  }
+  return out.slice(0, 6);
+}
+function questionToDisplayText(question) {
+  return String(question.query || question.question || "").trim();
+}
+function normalizeAskUserAnswerMeta(raw, questions, fallbackText) {
+  const validKeys = new Set(questions.map((question) => question.key));
+  const answersByKey = {};
+  if (raw?.answersByKey && typeof raw.answersByKey === "object") {
+    for (const [key, value] of Object.entries(raw.answersByKey)) {
+      if (!validKeys.has(key))
+        continue;
+      const normalizedValue = String(value || "").trim();
+      if (!normalizedValue)
+        continue;
+      answersByKey[key] = normalizedValue;
+    }
+  }
+  const fallback = String(fallbackText || "").trim();
+  if (Object.keys(answersByKey).length === 0 && fallback) {
+    if (questions.length === 1) {
+      answersByKey[questions[0].key] = fallback;
+    } else {
+      const lines = fallback.split("\n").map((line) => line.trim()).filter(Boolean);
+      for (const line of lines) {
+        const splitIndex = line.indexOf(":");
+        if (splitIndex <= 0)
+          continue;
+        const key = line.slice(0, splitIndex).trim();
+        const value = line.slice(splitIndex + 1).trim();
+        if (!key || !value || !validKeys.has(key))
+          continue;
+        answersByKey[key] = value;
+      }
+    }
+  }
+  const rawText = String(raw?.rawText || fallback || "").trim();
+  if (!rawText && Object.keys(answersByKey).length === 0)
+    return void 0;
+  return { answersByKey, rawText };
+}
+function buildAskUserAnswerContext(questions, answers) {
+  const lines = ["[ASK_USER_ANSWERS]"];
+  for (const question of questions) {
+    const answer = String(answers.answersByKey[question.key] || "").trim();
+    lines.push(`${question.key}: ${answer || "(no answer provided)"}`);
+  }
+  if (answers.rawText) {
+    lines.push("[RAW_USER_REPLY]");
+    lines.push(answers.rawText);
+  }
+  return lines.join("\n");
+}
 function buildPersistedState() {
   const safePrevSteps = sanitizeAgentPrevStepsForPersist(Array.isArray(agentPrevSteps) ? agentPrevSteps : []);
   return {
@@ -4446,7 +4657,12 @@ function buildPersistedState() {
     history: sanitizeHistoryForPersist(history),
     plannerHistory: sanitizePlannerHistoryForPersist(Array.isArray(plannerHistory) ? plannerHistory : []),
     agentPrevSteps: safePrevSteps,
-    lastToolPreviousSteps: safePrevSteps
+    lastToolPreviousSteps: safePrevSteps,
+    pendingAskUser: pendingAskUser ? {
+      questions: normalizePlannerQuestions(pendingAskUser.questions),
+      source: pendingAskUser.source,
+      askedAt: Number(pendingAskUser.askedAt) || Date.now()
+    } : void 0
   };
 }
 function postStateSnapshot() {
@@ -4479,6 +4695,16 @@ function hydrateState(raw) {
   } else if (Array.isArray(snapshot.lastToolPreviousSteps)) {
     agentPrevSteps = sanitizeAgentPrevStepsForPersist(snapshot.lastToolPreviousSteps);
   }
+  const hydratedQuestions = normalizePlannerQuestions(snapshot.pendingAskUser?.questions);
+  if (hydratedQuestions.length > 0) {
+    pendingAskUser = {
+      questions: hydratedQuestions,
+      source: snapshot.pendingAskUser?.source === "planner" ? "planner" : "act",
+      askedAt: Number(snapshot.pendingAskUser?.askedAt) || Date.now()
+    };
+  } else {
+    pendingAskUser = void 0;
+  }
   if (typeof snapshot.trajectoryId === "string" && snapshot.trajectoryId.trim()) {
     trajectoryId = snapshot.trajectoryId.trim();
   }
@@ -4487,146 +4713,131 @@ function hydrateState(raw) {
   }
   postStateSnapshot();
 }
-function shortText(value, max = 240) {
-  if (value == null)
-    return "";
-  const text = typeof value === "string" ? value : String(value);
-  const clean = text.trim();
-  if (!clean)
-    return "";
-  return clean.length <= max ? clean : `${clean.slice(0, max - 1)}\u2026`;
-}
-function formatInlineValue(value) {
-  if (value == null)
-    return "";
-  if (typeof value === "string")
-    return shortText(value, 200);
-  if (typeof value === "number" || typeof value === "boolean")
-    return String(value);
-  if (Array.isArray(value))
-    return `${value.length} item(s)`;
-  if (typeof value === "object") {
-    if (typeof value.message === "string")
-      return shortText(value.message, 200);
-    const keys = Object.keys(value);
-    if (!keys.length)
-      return "{}";
-    return `{ ${keys.slice(0, 4).join(", ")}${keys.length > 4 ? ", \u2026" : ""} }`;
-  }
-  return shortText(value, 200);
-}
-function formatObjectBlock(value) {
-  const preferredKeys = [
-    "message",
-    "summary",
-    "status",
-    "result",
-    "url",
-    "title",
-    "name",
-    "count",
-    "total",
-    "next_action"
-  ];
-  const entries = Object.entries(value).filter(([, v]) => v !== void 0 && v !== null && !(typeof v === "string" && !v.trim()));
-  if (!entries.length)
-    return "";
-  const sorted = entries.sort((a, b) => {
-    const ai = preferredKeys.indexOf(a[0]);
-    const bi = preferredKeys.indexOf(b[0]);
-    const ar = ai === -1 ? preferredKeys.length : ai;
-    const br = bi === -1 ? preferredKeys.length : bi;
-    return ar - br;
-  });
-  const lines = [];
-  const limit = 7;
-  const CONTENT_KEYS = /* @__PURE__ */ new Set(["response", "message", "summary", "result", "output", "text", "content", "description"]);
-  const URL_KEYS = /* @__PURE__ */ new Set(["url", "href", "link", "sheetUrl", "downloadUrl", "storageUrl"]);
-  for (const [key, raw] of sorted.slice(0, limit)) {
-    const isContent = CONTENT_KEYS.has(key);
-    const isUrl = URL_KEYS.has(key) || typeof raw === "string" && /^https?:\/\/.+/.test(raw.trim());
-    let rendered;
-    if (typeof raw === "string" && isUrl) {
-      const url = raw.trim();
-      rendered = `[${url}](${url})`;
-    } else if (typeof raw === "string" && isContent) {
-      rendered = shortText(raw, 2e3);
-    } else {
-      rendered = formatInlineValue(raw);
-    }
-    if (!rendered)
-      continue;
-    lines.push(`**${key}:** ${rendered}`);
-  }
-  if (sorted.length > limit) {
-    lines.push(`\u2026 ${sorted.length - limit} more field(s)`);
-  }
-  return lines.join("\n");
-}
-function formatArrayBlock(value) {
-  if (!value.length)
-    return "";
-  const lines = [];
-  const limit = 6;
-  for (const item of value.slice(0, limit)) {
-    if (typeof item === "string") {
-      const text = shortText(item, 260);
-      if (text)
-        lines.push(`- ${text}`);
+function sanitizeAssistantBlocks(input) {
+  if (!Array.isArray(input))
+    return void 0;
+  const out = [];
+  for (const raw of input) {
+    if (!raw || typeof raw !== "object")
       continue;
-    }
-    if (item && typeof item === "object") {
-      const block = formatObjectBlock(item);
-      if (block) {
-        if (lines.length > 0)
-          lines.push("---");
-        lines.push(block);
-      }
+    const type = raw.type;
+    if (type === "text") {
+      const text = String(raw.text || "").trim();
+      if (!text)
+        continue;
+      out.push({ type: "text", text });
       continue;
     }
-    if (item != null) {
-      lines.push(`- ${shortText(item, 260)}`);
+    if (type === "tool_output" || type === "json") {
+      out.push({
+        type,
+        data: cloneUnknown(raw.data),
+        label: typeof raw.label === "string" ? raw.label : void 0,
+        toolName: typeof raw.toolName === "string" ? raw.toolName : void 0
+      });
     }
   }
-  if (value.length > limit) {
-    lines.push(`- \u2026 ${value.length - limit} more item(s)`);
-  }
-  return lines.join("\n");
+  return out.length ? out : void 0;
 }
-function formatToolOutput(output) {
+function summarizeOutputText(output) {
   if (output == null)
-    return null;
+    return void 0;
   if (typeof output === "string") {
     const clean = output.trim();
-    return clean ? truncateText(clean, 12e3) : null;
+    return clean || void 0;
   }
   if (typeof output === "number" || typeof output === "boolean") {
     return String(output);
   }
   if (Array.isArray(output)) {
-    const block = formatArrayBlock(output);
-    if (block)
-      return truncateText(block, 12e3);
-  } else if (typeof output === "object") {
-    if (output.success === false && output.error) {
-      const message = shortText(output.error?.message || output.error, 300) || "Operation failed";
-      const nextAction = shortText(output.next_action || output.error?.next_action, 220);
-      const base = `[error] ${message}`;
-      return nextAction ? `${base}
-[next] ${nextAction}` : base;
-    }
-    const block = formatObjectBlock(output);
-    if (block)
-      return truncateText(block, 12e3);
+    const lines = [];
+    for (const item of output.slice(0, 4)) {
+      const candidate = summarizeOutputText(item);
+      if (candidate)
+        lines.push(candidate);
+      if (lines.length >= 3)
+        break;
+    }
+    if (lines.length)
+      return lines.join("\n");
+    return `Received ${output.length} item(s).`;
   }
-  try {
-    return truncateText(JSON.stringify(output, null, 2), 12e3);
-  } catch {
-    return truncateText(String(output), 12e3);
+  if (typeof output === "object") {
+    const preferredKeys = ["response", "message", "summary", "text", "content", "result", "description"];
+    for (const key of preferredKeys) {
+      const value = output[key];
+      if (typeof value === "string" && value.trim()) {
+        return value.trim();
+      }
+    }
+    const keys = Object.keys(output);
+    if (!keys.length)
+      return void 0;
+    return `Received ${keys.length} field(s).`;
   }
+  return void 0;
 }
-function postAssistantMessage(text) {
-  self.postMessage({ type: "assistant", text, runId: activeRun?.runId });
+function isSingleTextWrapperObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0 && v !== null);
+  if (entries.length !== 1)
+    return false;
+  const [key, raw] = entries[0];
+  if (typeof raw !== "string" || !raw.trim())
+    return false;
+  const textKeys = /* @__PURE__ */ new Set(["response", "message", "summary", "text", "content", "result", "description"]);
+  return textKeys.has(key);
+}
+function shouldAttachStructuredBlock(output, summaryText) {
+  if (output == null)
+    return false;
+  if (typeof output === "string") {
+    const clean = output.trim();
+    if (!clean)
+      return false;
+    return !summaryText || clean !== summaryText.trim();
+  }
+  if (Array.isArray(output)) {
+    const meaningful = output.filter((item) => item !== void 0 && item !== null);
+    if (meaningful.length === 1) {
+      const first = meaningful[0];
+      if (typeof first === "string" || typeof first === "number" || typeof first === "boolean") {
+        return false;
+      }
+      if (isSingleTextWrapperObject(first)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (isSingleTextWrapperObject(output)) {
+    return false;
+  }
+  return true;
+}
+function buildAssistantPayloadFromToolOutput(output, options) {
+  const summaryText = summarizeOutputText(output);
+  const text = summaryText || options?.fallbackText || "Done.";
+  const blocks = [];
+  if (shouldAttachStructuredBlock(output, summaryText)) {
+    blocks.push({
+      type: "tool_output",
+      label: options?.label,
+      toolName: options?.toolName,
+      data: cloneUnknown(output)
+    });
+  }
+  return { text, blocks: blocks.length ? blocks : void 0 };
+}
+function postAssistantMessage(payload) {
+  const text = typeof payload === "string" ? String(payload || "").trim() : String(payload?.text || "").trim();
+  const blocks = typeof payload === "string" ? void 0 : sanitizeAssistantBlocks(payload.blocks);
+  const firstTextBlock = blocks?.find((block) => block.type === "text");
+  const firstStructuredBlock = blocks?.find((block) => block.type === "tool_output" || block.type === "json");
+  const resolvedText = text || firstTextBlock?.text || summarizeOutputText(firstStructuredBlock?.data) || "Done.";
+  self.postMessage({ type: "assistant", text: resolvedText, blocks, runId: activeRun?.runId });
+  return resolvedText;
 }
 function dedupeFunctionDeclarations(declarations) {
   const seen = /* @__PURE__ */ new Set();
@@ -4664,11 +4875,6 @@ function toStructuredErrorPayload(err, fallbackMessage = "Operation failed") {
   };
   return payload;
 }
-function formatStructuredErrorForAssistant(payload) {
-  const summary = `${payload.error.code}: ${payload.error.message}`;
-  return `${summary}
-${JSON.stringify(payload, null, 2)}`;
-}
 function extractStructuredErrorFromToolResult(result) {
   if (!result || typeof result !== "object")
     return void 0;
@@ -4711,25 +4917,13 @@ function maybePostNavigationGuardrailFromToolResult(toolResult) {
   });
 }
 function buildChatLogFromHistory(input, currentUserInput) {
-  const sanitizeChatText = (raw, role) => {
-    let text = String(raw || "").replace(/\s+/g, " ").trim();
-    if (!text)
-      return "";
-    if (role === "assistant") {
-      if (/^\w[\w_]*:\s*\{/.test(text) || /^\[error\]/i.test(text) || /"success":\s*false/.test(text)) {
-        const firstSentence = text.split(/(?<=\.)\s+/)[0] || text;
-        text = firstSentence.trim();
-      }
-    }
-    if (text.length > MAX_CHATLOG_MESSAGE_CHARS2) {
-      text = `${text.slice(0, MAX_CHATLOG_MESSAGE_CHARS2 - 1)}\u2026`;
-    }
-    return text;
+  const sanitizeChatText = (raw) => {
+    return String(raw || "").replace(/\s+/g, " ").trim();
   };
-  const normalizedCurrentUserInput = currentUserInput ? sanitizeChatText(currentUserInput, "user") : "";
+  const normalizedCurrentUserInput = currentUserInput ? sanitizeChatText(currentUserInput) : "";
   const entries = input.filter((message) => message.role === "user" || message.role === "assistant").map((message) => ({
     role: message.role,
-    content: sanitizeChatText(String(message.content || ""), message.role)
+    content: sanitizeChatText(String(message.content || ""))
   })).filter((message) => !!message.content);
   if (normalizedCurrentUserInput) {
     for (let i = entries.length - 1; i >= 0; i -= 1) {
@@ -4746,11 +4940,25 @@ function buildChatLogFromHistory(input, currentUserInput) {
       continue;
     deduped.push(entry);
   }
-  const tail = deduped.slice(-MAX_CHATLOG_ENTRIES2);
-  while (tail.length > 1 && tail[0]?.role !== "user") {
-    tail.shift();
+  const firstUser = deduped.find((message) => message.role === "user");
+  const tailBudget = firstUser ? Math.max(1, MAX_CHATLOG_ENTRIES2 - 1) : MAX_CHATLOG_ENTRIES2;
+  let selected = deduped.slice(-tailBudget);
+  if (firstUser) {
+    const hasAnchor = selected.some((message) => message.role === "user" && message.content === firstUser.content);
+    if (!hasAnchor) {
+      selected = [firstUser, ...selected];
+    }
+  }
+  if (selected.length > MAX_CHATLOG_ENTRIES2) {
+    selected = selected.slice(-MAX_CHATLOG_ENTRIES2);
   }
-  return tail.map((message) => ({
+  if (selected.length > 1 && selected[0]?.role !== "user") {
+    const firstUserIndex = selected.findIndex((message) => message.role === "user");
+    if (firstUserIndex > 0) {
+      selected = selected.slice(firstUserIndex);
+    }
+  }
+  return selected.map((message) => ({
     role: message.role === "user" ? "user" : "model",
     message: message.content
   }));
@@ -4799,33 +5007,65 @@ function extractArtifactLinks(toolResult) {
   }
   return links;
 }
-function formatPlannerToolResults(toolResults) {
-  if (!Array.isArray(toolResults) || toolResults.length === 0)
-    return null;
-  const sections = [];
+function buildPlannerToolResultBlocks(toolResults) {
+  if (!Array.isArray(toolResults) || !toolResults.length)
+    return void 0;
+  const blocks = [];
   for (let i = 0; i < toolResults.length; i += 1) {
     const result = toolResults[i];
     if (!result)
       continue;
+    const stepLabel = `Step ${i + 1}`;
     const output = result.output ?? result.generatedContentRef ?? result.schemaHeaderSheetInfo;
-    const outputText = formatToolOutput(output);
+    const summary = summarizeOutputText(output);
+    if (output !== void 0 && shouldAttachStructuredBlock(output, summary)) {
+      blocks.push({
+        type: "tool_output",
+        label: result.toolName ? `${stepLabel}: ${result.toolName}` : stepLabel,
+        toolName: typeof result.toolName === "string" ? result.toolName : void 0,
+        data: cloneUnknown(output)
+      });
+    }
+    if (result.error || result.errorDetails) {
+      blocks.push({
+        type: "json",
+        label: `${stepLabel} error`,
+        data: cloneUnknown({
+          error: result.error,
+          errorDetails: result.errorDetails
+        })
+      });
+    }
     const links = extractArtifactLinks(result);
-    const lines = [];
-    if (outputText)
-      lines.push(outputText);
-    if (result.error)
-      lines.push(`Error: ${String(result.error)}`);
-    if (links.length)
-      lines.push(`Artifacts:
-${links.map((link) => `- ${link}`).join("\n")}`);
-    if (!lines.length)
+    if (links.length) {
+      blocks.push({
+        type: "text",
+        text: `${stepLabel} artifacts:
+${links.map((link) => `- ${link}`).join("\n")}`
+      });
+    }
+  }
+  return blocks.length ? blocks : void 0;
+}
+function summarizePlannerToolResults(toolResults) {
+  if (!Array.isArray(toolResults) || !toolResults.length)
+    return void 0;
+  const lines = [];
+  for (let i = 0; i < toolResults.length; i += 1) {
+    const result = toolResults[i];
+    if (!result)
       continue;
-    sections.push(`Step ${i + 1}
-${lines.join("\n")}`);
+    const output = result.output ?? result.generatedContentRef ?? result.schemaHeaderSheetInfo;
+    const summary = summarizeOutputText(output);
+    if (summary) {
+      lines.push(summary);
+      if (lines.length >= 3)
+        break;
+    }
   }
-  if (!sections.length)
-    return null;
-  return truncateText(sections.join("\n\n"), 12e3);
+  if (!lines.length)
+    return void 0;
+  return lines.join("\n\n");
 }
 function extractLatestPrevStepsFromPlanner(toolResults) {
   if (!Array.isArray(toolResults) || !toolResults.length)
@@ -4871,16 +5111,48 @@ function detectOpenedTabFromToolResult(result) {
   }
   return void 0;
 }
+function extractQuestionsFromResult(result) {
+  if (!result || typeof result !== "object")
+    return void 0;
+  const topLevel = normalizePlannerQuestions(result.questions);
+  if (topLevel.length)
+    return topLevel;
+  const output = result.output;
+  const outputQuestions = normalizePlannerQuestions(output?.questions);
+  if (outputQuestions.length)
+    return outputQuestions;
+  return void 0;
+}
+function extractPlannerQuestionsFromToolResults(toolResults) {
+  if (!Array.isArray(toolResults) || toolResults.length === 0)
+    return [];
+  const combined = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const toolResult of toolResults) {
+    const questions = extractQuestionsFromResult(toolResult);
+    if (!questions || !questions.length)
+      continue;
+    for (const question of questions) {
+      const key = `${question.key}::${question.query}`.toLowerCase();
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      combined.push(question);
+    }
+  }
+  return combined.slice(0, 6);
+}
 function deriveDirectToolRunOutcome(result) {
   if (!result || typeof result !== "object") {
     return { taskComplete: false };
   }
+  const questions = extractQuestionsFromResult(result);
   const topLevelStatus = String(result.status || "").trim().toLowerCase();
   if (topLevelStatus === "failure" || topLevelStatus === "failed" || topLevelStatus === "error") {
     return { taskComplete: false };
   }
   if (topLevelStatus === "waiting_input" || topLevelStatus === "needs_input" || topLevelStatus === "pending_user_input") {
-    return { taskComplete: false, needsUserInput: true };
+    return { taskComplete: false, needsUserInput: true, questions };
   }
   if (result.error) {
     return { taskComplete: false };
@@ -4891,10 +5163,10 @@ function deriveDirectToolRunOutcome(result) {
       return { taskComplete: true };
     }
     if (output.needsUserInput === true || output.waitingForUserInput === true) {
-      return { taskComplete: false, needsUserInput: true };
+      return { taskComplete: false, needsUserInput: true, questions };
     }
     if (Array.isArray(output.questions) && output.questions.length > 0) {
-      return { taskComplete: false, needsUserInput: true };
+      return { taskComplete: false, needsUserInput: true, questions };
     }
     if (output.error) {
       return { taskComplete: false };
@@ -4927,7 +5199,7 @@ function deriveDirectToolRunOutcome(result) {
   if (output != null) {
     return { taskComplete: true };
   }
-  return { taskComplete: false };
+  return { taskComplete: true };
 }
 function normalizeRunOutcome(outcome) {
   if (!outcome || typeof outcome !== "object") {
@@ -4935,16 +5207,37 @@ function normalizeRunOutcome(outcome) {
   }
   const needsUserInput = outcome.needsUserInput === true;
   const taskComplete = outcome.taskComplete === true && !needsUserInput;
+  const questions = normalizePlannerQuestions(outcome.questions);
   return {
     route: outcome.route,
     taskComplete,
-    needsUserInput
+    needsUserInput,
+    questions: questions.length ? questions : void 0
   };
 }
+function rememberTerminalRun(runId, result) {
+  terminalRuns.set(runId, result);
+  while (terminalRuns.size > 80) {
+    const oldest = terminalRuns.keys().next().value;
+    if (!oldest)
+      break;
+    terminalRuns.delete(oldest);
+  }
+}
+function rememberCancelledRun(runId) {
+  cancelledRunIds.add(runId);
+  while (cancelledRunIds.size > 80) {
+    const oldest = cancelledRunIds.values().next().value;
+    if (!oldest)
+      break;
+    cancelledRunIds.delete(oldest);
+  }
+}
 function clearTaskScopedContextAfterCompletion() {
   history.length = 0;
   plannerHistory = [];
   agentPrevSteps = [];
+  pendingAskUser = void 0;
 }
 async function maybeWaitForNewTab(result) {
   const logicalTabId = detectOpenedTabFromToolResult(result);
@@ -4964,6 +5257,34 @@ async function handleUserMessage(text, options) {
     history.push({ role: "user", content: text });
     postStateSnapshot();
   }
+  let effectiveUserInput = text;
+  if (pendingAskUser?.questions?.length) {
+    const normalizedAnswers = normalizeAskUserAnswerMeta(options?.askUserAnswers, pendingAskUser.questions, text);
+    if (normalizedAnswers) {
+      const answerContext = buildAskUserAnswerContext(pendingAskUser.questions, normalizedAnswers);
+      effectiveUserInput = answerContext;
+      plannerHistory = sanitizePlannerHistoryForPersist([
+        ...plannerHistory,
+        {
+          thought: "User provided clarification answers.",
+          questionsAsked: pendingAskUser.questions,
+          userAnswers: normalizedAnswers.answersByKey
+        }
+      ]);
+      applyAgentPrevSteps([
+        ...agentPrevSteps,
+        {
+          thought: "User provided clarification answers.",
+          data: JSON.stringify({
+            ask_user_answers: normalizedAnswers.answersByKey,
+            raw_user_reply: normalizedAnswers.rawText
+          })
+        }
+      ], { snapshot: false });
+      pendingAskUser = void 0;
+      postStateSnapshot();
+    }
+  }
   const tabs = await getKnownTabs();
   const fallbackTabs = tabs.length > 0 ? tabs : [
     {
@@ -5010,7 +5331,7 @@ async function handleUserMessage(text, options) {
     }
   }, bridgeRpc, tabularStore);
   const currentRunId = activeRun?.runId;
-  ctx.isCancelled = () => cancelledRunId === currentRunId;
+  ctx.isCancelled = () => !!(currentRunId && cancelledRunIds.has(currentRunId));
   const functionDeclarations = dedupeFunctionDeclarations(removePlannerNameCollisions(toolRegistry.getFunctionDeclarations()));
   const toolFunctions = toolRegistry.getToolFunctions();
   const chatLog = buildChatLogFromHistory(history, text);
@@ -5021,7 +5342,7 @@ async function handleUserMessage(text, options) {
     plannerHistory = sanitizePlannerHistoryForPersist(Array.isArray(steps) ? steps : []);
     postStateSnapshot();
   };
-  const result = await handleSendMessageWithFunctions(text, {
+  const result = await handleSendMessageWithFunctions(effectiveUserInput, {
     tabs: tabsForRun,
     previousMessages: history,
     trajectoryId,
@@ -5035,7 +5356,7 @@ async function handleUserMessage(text, options) {
       chatLog
     },
     lastToolPreviousSteps: agentPrevSteps,
-    taskRouting: config.taskRouting,
+    taskRouting: options?.routing ? { ...config.taskRouting, mode: options.routing } : config.taskRouting,
     ctx,
     bridgeRpc,
     functionDeclarations,
@@ -5047,8 +5368,16 @@ async function handleUserMessage(text, options) {
     if (errorPayload.error.requires_api_key) {
       postAuthRequired(errorPayload.error);
     }
-    const errorMsg = formatStructuredErrorForAssistant(errorPayload);
-    postAssistantMessage(errorMsg);
+    const errorMsg = postAssistantMessage({
+      text: `${errorPayload.error.code}: ${errorPayload.error.message}`,
+      blocks: [
+        {
+          type: "json",
+          label: "Error details",
+          data: cloneUnknown(errorPayload)
+        }
+      ]
+    });
     history.push({ role: "assistant", content: errorMsg });
     postStatus("Execution failed", errorPayload.error.message, "complete");
     postStateSnapshot();
@@ -5058,12 +5387,31 @@ async function handleUserMessage(text, options) {
     for (const fn of result.executedFunctions) {
       applyAgentPrevSteps(fn.prevSteps, { snapshot: false });
     }
-    const lines = result.executedFunctions.map((fn) => {
-      const out = formatToolOutput(fn.result);
-      return out ? `@${fn.name}: ${out}` : `@${fn.name}: ${fn.error || "ok"}`;
+    const blocks = [];
+    const lines = [];
+    for (const fn of result.executedFunctions) {
+      const summary = summarizeOutputText(fn.result);
+      if (fn.result !== void 0 && shouldAttachStructuredBlock(fn.result, summary)) {
+        blocks.push({
+          type: "tool_output",
+          toolName: fn.name,
+          label: `${fn.name} output`,
+          data: cloneUnknown(fn.result)
+        });
+      }
+      if (fn.error) {
+        blocks.push({
+          type: "json",
+          label: `${fn.name} error`,
+          data: cloneUnknown({ error: fn.error })
+        });
+      }
+      lines.push(summary ? `@${fn.name}: ${summary}` : `@${fn.name}: ${fn.error || "ok"}`);
+    }
+    const msg = postAssistantMessage({
+      text: lines.join("\n") || "Done.",
+      blocks
     });
-    const msg = lines.join("\n");
-    postAssistantMessage(msg);
     history.push({ role: "assistant", content: msg });
     postStatus("Execution completed", "Function calls finished", "complete");
     postStateSnapshot();
@@ -5074,55 +5422,121 @@ async function handleUserMessage(text, options) {
     postStatus("Verifying result", void 0, "verify");
     maybePostNavigationGuardrailFromToolResult(result.directToolResult);
     applyAgentPrevSteps(result.directToolResult.prevSteps, { snapshot: false });
+    const outcome = deriveDirectToolRunOutcome(result.directToolResult);
+    const questions = normalizePlannerQuestions(outcome.questions);
+    if (outcome.needsUserInput && questions.length > 0) {
+      pendingAskUser = {
+        questions,
+        source: "act",
+        askedAt: Date.now()
+      };
+      plannerHistory = sanitizePlannerHistoryForPersist([
+        ...plannerHistory,
+        {
+          thought: "Need user clarification before continuing act workflow.",
+          questionsAsked: questions
+        }
+      ]);
+      const qText = questions.map((question) => `- ${question.key}: ${questionToDisplayText(question)}`).join("\n");
+      const msg2 = postAssistantMessage(`I need a bit more info before continuing:
+${qText}`);
+      history.push({ role: "assistant", content: msg2 });
+      postStatus("Need more input to continue", void 0, "verify");
+      postStateSnapshot();
+      return {
+        route: result.route,
+        taskComplete: false,
+        needsUserInput: true,
+        questions
+      };
+    }
+    pendingAskUser = void 0;
     const output = result.directToolResult.output ?? result.directToolResult.generatedContentRef ?? result.directToolResult.schemaHeaderSheetInfo;
-    const formattedOutput = output ? formatToolOutput(output) : null;
     const structuredError = extractStructuredErrorFromToolResult(result.directToolResult);
     if (structuredError?.error.requires_api_key) {
       postAuthRequired(structuredError.error);
     }
-    const msg = structuredError ? formatStructuredErrorForAssistant(structuredError) : formattedOutput ?? "Done.";
-    postAssistantMessage(msg);
+    const msg = structuredError ? postAssistantMessage({
+      text: `${structuredError.error.code}: ${structuredError.error.message}`,
+      blocks: [
+        {
+          type: "json",
+          label: "Error details",
+          data: cloneUnknown(structuredError)
+        }
+      ]
+    }) : postAssistantMessage(buildAssistantPayloadFromToolOutput(output, {
+      label: "Tool output",
+      fallbackText: "Done."
+    }));
     history.push({ role: "assistant", content: msg });
     postStatus("Execution completed", structuredError?.error.message, "complete");
     postStateSnapshot();
-    const outcome = deriveDirectToolRunOutcome(result.directToolResult);
     return {
       route: result.route,
       taskComplete: outcome.taskComplete,
-      needsUserInput: outcome.needsUserInput
+      needsUserInput: outcome.needsUserInput,
+      questions: normalizePlannerQuestions(outcome.questions)
     };
   }
   if (result.plannerResponse) {
     postStatus("Verifying planner output", void 0, "verify");
     const response = result.plannerResponse.response;
+    const toolResults = result.plannerResponse.toolResults || [];
     if (result.plannerResponse.previousSteps) {
       plannerHistory = result.plannerResponse.previousSteps;
       postStateSnapshot();
     }
-    const latestToolPrevSteps = extractLatestPrevStepsFromPlanner(result.plannerResponse.toolResults);
+    const latestToolPrevSteps = extractLatestPrevStepsFromPlanner(toolResults);
     applyAgentPrevSteps(latestToolPrevSteps, { snapshot: false });
-    if (response.questions?.length) {
-      const qText = response.questions.map((q) => `- ${q.question}`).join("\n");
+    const responseQuestions = normalizePlannerQuestions(response.questions);
+    const fallbackQuestions = responseQuestions.length ? [] : extractPlannerQuestionsFromToolResults(toolResults);
+    const plannerQuestions = responseQuestions.length ? responseQuestions : fallbackQuestions;
+    if (plannerQuestions.length) {
+      const questions = plannerQuestions;
+      pendingAskUser = questions.length ? {
+        questions,
+        source: "planner",
+        askedAt: Date.now()
+      } : void 0;
+      const qText = questions.map((question) => `- ${question.key}: ${questionToDisplayText(question)}`).join("\n");
       const msg2 = `I need a bit more info:
 ${qText}`;
       postAssistantMessage(msg2);
       history.push({ role: "assistant", content: msg2 });
       postStatus("Planner needs user input", void 0, "verify");
       postStateSnapshot();
-      return { route: result.route, taskComplete: false, needsUserInput: true };
+      return {
+        route: result.route,
+        taskComplete: false,
+        needsUserInput: true,
+        questions
+      };
     }
-    const toolResults = result.plannerResponse.toolResults || [];
+    pendingAskUser = void 0;
     for (const toolResult of toolResults) {
       await maybeWaitForNewTab(toolResult);
       maybePostNavigationGuardrailFromToolResult(toolResult);
     }
-    const formattedOutput = formatPlannerToolResults(toolResults);
+    const toolBlocks = buildPlannerToolResultBlocks(toolResults);
     const responseError = response.error || response.errorDetails ? toStructuredErrorPayload(response.errorDetails || { message: response.error }, "Planner failed") : void 0;
     if (responseError?.error.requires_api_key) {
       postAuthRequired(responseError.error);
     }
-    const msg = formattedOutput ?? (responseError ? formatStructuredErrorForAssistant(responseError) : response.overallThought ?? "Done.");
-    postAssistantMessage(msg);
+    const msg = responseError ? postAssistantMessage({
+      text: `${responseError.error.code}: ${responseError.error.message}`,
+      blocks: [
+        {
+          type: "json",
+          label: "Planner error",
+          data: cloneUnknown(responseError)
+        },
+        ...toolBlocks || []
+      ]
+    }) : postAssistantMessage({
+      text: String(response.overallThought || summarizePlannerToolResults(toolResults) || "Done."),
+      blocks: toolBlocks
+    });
     history.push({ role: "assistant", content: msg });
     postStatus("Planner execution completed", response.overallThought, "complete");
     postStateSnapshot();
@@ -5132,24 +5546,37 @@ ${qText}`;
       needsUserInput: false
     };
   }
-  postAssistantMessage("Done.");
-  history.push({ role: "assistant", content: "Done." });
+  const doneMsg = postAssistantMessage("Done.");
+  history.push({ role: "assistant", content: doneMsg });
   postStatus("Completed", void 0, "complete");
   postStateSnapshot();
   return { route: result.route, taskComplete: true };
 }
 async function runUserMessage(text, meta) {
   const runId = meta?.runId || crypto.randomUUID();
-  if (completedRunIds.has(runId)) {
-    const cachedOutcome = normalizeRunOutcome(completedRunOutcomes.get(runId));
-    self.postMessage({
-      type: "run_completed",
-      runId,
-      ok: true,
-      route: cachedOutcome.route,
-      taskComplete: cachedOutcome.taskComplete,
-      needsUserInput: cachedOutcome.needsUserInput
-    });
+  const terminal = terminalRuns.get(runId);
+  if (terminal) {
+    if (terminal.ok) {
+      const cachedOutcome = normalizeRunOutcome(terminal.outcome);
+      self.postMessage({
+        type: "run_completed",
+        runId,
+        ok: true,
+        route: cachedOutcome.route,
+        taskComplete: cachedOutcome.taskComplete,
+        needsUserInput: cachedOutcome.needsUserInput,
+        questions: cachedOutcome.questions
+      });
+    } else {
+      self.postMessage({
+        type: "run_completed",
+        runId,
+        ok: false,
+        error: terminal.error,
+        taskComplete: false,
+        needsUserInput: false
+      });
+    }
     return;
   }
   if (activeRun && activeRun.runId === runId) {
@@ -5158,20 +5585,26 @@ async function runUserMessage(text, meta) {
   const resume = !!meta?.resume;
   lastStatusKey = "";
   seenStatusKeys = /* @__PURE__ */ new Set();
+  cancelledRunIds.delete(runId);
   activeAbortController = new AbortController();
   activeRun = { runId, text, startedAt: Date.now(), resume };
   self.postMessage({ type: "run_started", runId, text, resume });
   postStateSnapshot();
   try {
-    const outcome = normalizeRunOutcome(await handleUserMessage(text, { resume }));
-    completedRunOutcomes.set(runId, outcome);
+    const outcome = normalizeRunOutcome(await handleUserMessage(text, {
+      resume,
+      routing: meta?.routing,
+      askUserAnswers: meta?.askUserAnswers
+    }));
+    rememberTerminalRun(runId, { ok: true, outcome });
     self.postMessage({
       type: "run_completed",
       runId,
       ok: true,
       route: outcome.route,
       taskComplete: outcome.taskComplete,
-      needsUserInput: outcome.needsUserInput
+      needsUserInput: outcome.needsUserInput,
+      questions: outcome.questions
     });
     if (outcome.taskComplete && !outcome.needsUserInput) {
       clearTaskScopedContextAfterCompletion();
@@ -5179,6 +5612,12 @@ async function runUserMessage(text, meta) {
     }
   } catch (error) {
     if (error?.name === "AbortError") {
+      rememberTerminalRun(runId, {
+        ok: false,
+        error: "Run cancelled",
+        taskComplete: false,
+        needsUserInput: false
+      });
       self.postMessage({
         type: "run_completed",
         runId,
@@ -5188,6 +5627,12 @@ async function runUserMessage(text, meta) {
         needsUserInput: false
       });
     } else {
+      rememberTerminalRun(runId, {
+        ok: false,
+        error: error?.message || String(error),
+        taskComplete: false,
+        needsUserInput: false
+      });
       self.postMessage({
         type: "run_completed",
         runId,
@@ -5201,14 +5646,6 @@ async function runUserMessage(text, meta) {
   } finally {
     activeAbortController = null;
     activeRun = null;
-    completedRunIds.add(runId);
-    if (completedRunIds.size > 50) {
-      const oldest = completedRunIds.values().next().value;
-      if (oldest) {
-        completedRunIds.delete(oldest);
-        completedRunOutcomes.delete(oldest);
-      }
-    }
     postStateSnapshot();
   }
 }
@@ -5256,6 +5693,9 @@ self.onmessage = async (ev) => {
         trajectoryId = partial.sessionId.trim();
         plannerHistory = [];
         agentPrevSteps = [];
+        pendingAskUser = void 0;
+        terminalRuns.clear();
+        cancelledRunIds.clear();
         tabularStore = new TabularStore(`rover-${trajectoryId}`);
       }
       const tools = partial.tools;
@@ -5279,29 +5719,45 @@ self.onmessage = async (ev) => {
       if (!config)
         throw new Error("Worker not initialized");
       const nextTaskId = typeof data.taskId === "string" && data.taskId.trim() ? data.taskId.trim() : crypto.randomUUID();
+      activeAbortController?.abort();
       history.length = 0;
       plannerHistory = [];
       agentPrevSteps = [];
+      pendingAskUser = void 0;
+      terminalRuns.clear();
+      cancelledRunIds.clear();
       trajectoryId = nextTaskId;
       tabularStore = new TabularStore(`rover-${trajectoryId}`);
       activeRun = null;
+      activeAbortController = null;
       postStateSnapshot();
       self.postMessage({ type: "task_started", taskId: nextTaskId });
       return;
     }
     if (data.type === "cancel_run") {
       if (typeof data.runId === "string" && data.runId) {
-        cancelledRunId = data.runId;
+        rememberCancelledRun(data.runId);
         activeAbortController?.abort();
       }
+      pendingAskUser = void 0;
+      postStateSnapshot();
       return;
     }
     if (data.type === "run") {
-      await runUserMessage(String(data.text || ""), { runId: data.runId, resume: !!data.resume });
+      await runUserMessage(String(data.text || ""), {
+        runId: data.runId,
+        resume: !!data.resume,
+        routing: data.routing,
+        askUserAnswers: data.askUserAnswers
+      });
       return;
     }
     if (data.type === "user") {
-      await runUserMessage(String(data.text || ""), { runId: data.runId, resume: !!data.resume });
+      await runUserMessage(String(data.text || ""), {
+        runId: data.runId,
+        resume: !!data.resume,
+        askUserAnswers: data.askUserAnswers
+      });
       return;
     }
   } catch (err) {