@mindstudio-ai/remy 0.1.265 → 0.1.267

package/dist/headless.js

@@ -2082,6 +2082,12 @@ var setProjectMetadataTool = {
 
 // src/tools/common/compactConversation.ts
 var compactConversationTool = {
+  backgroundOnly: true,
+  // Silent: the completed summary is written onto the tool block for the UI
+  // detail view only. The model must never receive it as a message — it gets
+  // the summary the correct way, as the checkpoint prefix in every later API
+  // call (cleanMessagesForApi).
+  backgroundNotify: "silent",
   definition: {
     clearable: false,
     name: "compactConversation",
@@ -2095,11 +2101,32 @@ var compactConversationTool = {
     if (!context?.conversationMessages || !context.apiConfig) {
       return "Error: compaction requires execution context.";
     }
+    const { toolCallId, onBackgroundComplete, toolRegistry } = context;
     triggerCompaction(
       { messages: context.conversationMessages },
       context.apiConfig,
-      { blocking: false, requestId: context.requestId }
-    ).catch(() => {
+      // origin/toolCallId tell the headless listener a real block exists —
+      // it must not synthesize a UI-only one for this compaction.
+      {
+        blocking: false,
+        requestId: context.requestId,
+        origin: "tool",
+        toolCallId
+      }
+    ).then((summaries) => {
+      onBackgroundComplete?.(
+        toolCallId,
+        "compactConversation",
+        formatSummariesResult(summaries)
+      );
+    }).catch((err) => {
+      onBackgroundComplete?.(
+        toolCallId,
+        "compactConversation",
+        `Error: ${err.message || "Compaction failed"}`
+      );
+    }).finally(() => {
+      toolRegistry?.unregister(toolCallId);
     });
     return "Compaction started in the background.";
   }
@@ -3385,16 +3412,55 @@ function capToolResult(result) {
 }
 
 // src/statusWatcher.ts
+var INTERNAL_PAYLOAD_MARKERS = [
+  "[USER CANCELLED]",
+  "[INTERRUPTED]",
+  "[INTERRUPTED - PARTIAL OUTPUT RETRIEVED]",
+  "<background_results>",
+  "<tool_result"
+];
+function sanitizeStatusText(text) {
+  if (!text) {
+    return "";
+  }
+  for (const marker of INTERNAL_PAYLOAD_MARKERS) {
+    if (text.includes(marker)) {
+      return "";
+    }
+  }
+  const truncIdx = text.indexOf("(tool result truncated at");
+  return truncIdx === -1 ? text : text.slice(0, truncIdx);
+}
 function startStatusWatcher(config) {
   const { apiConfig, getContext, onStatus, interval = 5e3, signal } = config;
   let inflight2 = false;
   let stopped = false;
   let pauseCount = 0;
   const url = `${apiConfig.baseUrl}/_internal/v2/agent/remy/generate-status`;
+  let consecutiveFailures = 0;
+  let backoffMs = 0;
+  let nextAllowedAt = 0;
+  const MAX_CONSECUTIVE_FAILURES = 10;
+  const MAX_BACKOFF_MS = 6e4;
+  function recordFailure() {
+    consecutiveFailures++;
+    backoffMs = Math.min(
+      backoffMs === 0 ? interval : backoffMs * 2,
+      MAX_BACKOFF_MS
+    );
+    nextAllowedAt = Date.now() + backoffMs;
+    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && !stopped) {
+      stopped = true;
+      clearInterval(timer);
+    }
+  }
   async function tick() {
     if (stopped || signal?.aborted || inflight2 || pauseCount > 0) {
       return;
     }
+    if (Date.now() < nextAllowedAt) {
+      return;
+    }
     inflight2 = true;
     try {
       const context = getContext();
@@ -3410,18 +3476,29 @@ function startStatusWatcher(config) {
         body: JSON.stringify({ appId: apiConfig.appId, context }),
         signal
       });
-      if (!res.ok || stopped) {
+      if (stopped) {
+        return;
+      }
+      if (!res.ok) {
+        recordFailure();
         return;
       }
       const data = await res.json();
       if (!data.label) {
+        recordFailure();
         return;
       }
+      consecutiveFailures = 0;
+      backoffMs = 0;
+      nextAllowedAt = 0;
       if (pauseCount > 0 || stopped || signal?.aborted) {
         return;
       }
       onStatus(data.label);
     } catch {
+      if (!stopped && !signal?.aborted) {
+        recordFailure();
+      }
     } finally {
       inflight2 = false;
     }
@@ -3518,7 +3595,12 @@ ${summaryBlock.text}
     }
     startIdx = checkpointIdx + 1;
   }
-  const messagesToProcess = fixOrphanedToolCalls(messages.slice(startIdx));
+  const apiMessages = messages.slice(startIdx).filter(
+    (msg) => !(msg.role === "assistant" && Array.isArray(msg.content) && msg.content.some(
+      (b) => b.type === "tool" && b.uiOnly
+    ))
+  );
+  const messagesToProcess = fixOrphanedToolCalls(apiMessages);
   const toolUseIds = /* @__PURE__ */ new Set();
   for (const msg of messagesToProcess) {
     if (msg.role === "assistant" && Array.isArray(msg.content)) {
@@ -3660,329 +3742,341 @@ ${partial}` : "[INTERRUPTED] Agent was interrupted before producing output.",
       return { text: USER_CANCELLED_RESULT, messages: thisInvocation() };
     }
     let lastToolResult = "";
-    while (true) {
-      turns++;
-      if (signal?.aborted) {
-        return abortResult([]);
-      }
-      const iterStart = Date.now();
-      const contentBlocks = [];
-      let thinkingStartedAt = 0;
-      let lastThinkingRelatedStartedAt;
-      let stopReason = "end_turn";
-      let currentToolNames = "";
-      let lastUsage;
-      let lastProviderMetadata;
-      let lastModelId;
-      const statusWatcher = startStatusWatcher({
-        apiConfig,
-        getContext: () => {
-          const parts = [];
-          if (task) {
-            parts.push(`Task: ${task.slice(-200)}`);
-          }
-          const text = getPartialText(contentBlocks);
-          if (text) {
-            parts.push(`Assistant text: ${text.slice(-500)}`);
-          }
-          if (currentToolNames) {
-            parts.push(`Tool: ${currentToolNames}`);
-          }
-          if (lastToolResult) {
-            parts.push(`Tool result: ${lastToolResult.slice(-200)}`);
-          }
-          return parts.join("\n");
-        },
-        onStatus: (label) => emit({ type: "status", message: label }),
-        signal
-      });
-      try {
-        for await (const event of streamChatWithRetry(
-          {
-            ...apiConfig,
-            model,
-            requestId,
-            subAgentId,
-            system: fullSystem,
-            messages: cleanMessagesForApi(messages),
-            tools: tools2,
-            signal
-          },
-          {
-            onRetry: (attempt) => emit({
-              type: "status",
-              message: `Lost connection, retrying (attempt ${attempt + 2} of 3)`
-            })
+    let watchedBlocks = [];
+    let watchedToolNames = "";
+    const statusWatcher = startStatusWatcher({
+      apiConfig,
+      getContext: () => {
+        const parts = [];
+        if (task) {
+          parts.push(`Task: ${sanitizeStatusText(task).slice(-200)}`);
+        }
+        const text = getPartialText(watchedBlocks);
+        if (text) {
+          parts.push(`Assistant text: ${text.slice(-500)}`);
+        }
+        if (watchedToolNames) {
+          parts.push(`Tool: ${watchedToolNames}`);
+        }
+        const toolResult = sanitizeStatusText(lastToolResult);
+        if (toolResult) {
+          parts.push(`Tool result: ${toolResult.slice(-200)}`);
+        }
+        return parts.join("\n");
+      },
+      onStatus: (label) => emit({ type: "status", message: label }),
+      signal
+    });
+    try {
+      while (true) {
+        turns++;
+        if (signal?.aborted) {
+          return abortResult([]);
+        }
+        const iterStart = Date.now();
+        const contentBlocks = [];
+        let thinkingStartedAt = 0;
+        let lastThinkingRelatedStartedAt;
+        let stopReason = "end_turn";
+        let lastUsage;
+        let lastProviderMetadata;
+        let lastModelId;
+        watchedBlocks = contentBlocks;
+        watchedToolNames = "";
+        try {
+          for await (const event of streamChatWithRetry(
+            {
+              ...apiConfig,
+              model,
+              requestId,
+              subAgentId,
+              system: fullSystem,
+              messages: cleanMessagesForApi(messages),
+              tools: tools2,
+              signal
+            },
+            {
+              onRetry: (attempt) => emit({
+                type: "status",
+                message: `Lost connection, retrying (attempt ${attempt + 2} of 3)`
+              })
+            }
+          )) {
+            if (signal?.aborted) {
+              break;
+            }
+            switch (event.type) {
+              case "text": {
+                const lastBlock = contentBlocks.at(-1);
+                if (lastBlock?.type === "text") {
+                  lastBlock.text += event.text;
+                } else {
+                  contentBlocks.push({
+                    type: "text",
+                    text: event.text,
+                    startedAt: event.ts
+                  });
+                }
+                emit({ type: "text", text: event.text });
+                break;
+              }
+              case "thinking":
+                if (!thinkingStartedAt) {
+                  thinkingStartedAt = event.ts;
+                }
+                emit({ type: "thinking", text: event.text });
+                break;
+              case "thinking_complete":
+                contentBlocks.push({
+                  type: "thinking",
+                  thinking: event.thinking,
+                  signature: event.signature,
+                  startedAt: thinkingStartedAt,
+                  completedAt: event.ts
+                });
+                lastThinkingRelatedStartedAt = thinkingStartedAt;
+                thinkingStartedAt = 0;
+                break;
+              case "redacted_thinking_complete": {
+                const startedAt = lastThinkingRelatedStartedAt !== void 0 ? lastThinkingRelatedStartedAt + 1 : event.ts;
+                contentBlocks.push({
+                  type: "redacted_thinking",
+                  data: event.data,
+                  startedAt,
+                  completedAt: event.ts
+                });
+                lastThinkingRelatedStartedAt = startedAt;
+                break;
+              }
+              case "tool_use":
+                contentBlocks.push({
+                  type: "tool",
+                  id: event.id,
+                  name: event.name,
+                  input: event.input,
+                  startedAt: Date.now()
+                });
+                emit({
+                  type: "tool_start",
+                  id: event.id,
+                  name: event.name,
+                  input: event.input
+                });
+                break;
+              case "done":
+                stopReason = event.stopReason;
+                lastUsage = {
+                  inputTokens: event.usage.inputTokens,
+                  outputTokens: event.usage.outputTokens,
+                  cacheCreationTokens: event.usage.cacheCreationTokens,
+                  cacheReadTokens: event.usage.cacheReadTokens,
+                  llmCalls: 1
+                };
+                lastProviderMetadata = event.providerMetadata;
+                lastModelId = event.modelId;
+                recordUsage({
+                  ts: Date.now(),
+                  requestId,
+                  agentName: subAgentId || "sub-agent",
+                  parentToolId,
+                  modelId: event.modelId,
+                  inputTokens: event.usage.inputTokens,
+                  outputTokens: event.usage.outputTokens,
+                  cacheCreationTokens: event.usage.cacheCreationTokens,
+                  cacheReadTokens: event.usage.cacheReadTokens,
+                  cost: nanoToDollars(event.cost),
+                  billingEvents: event.billingEvents,
+                  durationMs: Date.now() - iterStart,
+                  toolNames: contentBlocks.filter(
+                    (b) => b.type === "tool"
+                  ).map((b) => b.name)
+                });
+                break;
+              case "error":
+                statusWatcher.stop();
+                return {
+                  text: `Error: ${event.error}`,
+                  messages: thisInvocation()
+                };
+            }
           }
-        )) {
-          if (signal?.aborted) {
-            break;
+        } catch (err) {
+          if (!signal?.aborted) {
+            throw err;
           }
-          switch (event.type) {
-            case "text": {
-              const lastBlock = contentBlocks.at(-1);
-              if (lastBlock?.type === "text") {
-                lastBlock.text += event.text;
-              } else {
-                contentBlocks.push({
-                  type: "text",
-                  text: event.text,
-                  startedAt: event.ts
+        }
+        if (signal?.aborted) {
+          statusWatcher.stop();
+          return abortResult(contentBlocks);
+        }
+        messages.push({
+          role: "assistant",
+          content: contentBlocks,
+          ...lastUsage ? { usage: lastUsage } : {},
+          ...lastProviderMetadata ? { providerMetadata: lastProviderMetadata } : {},
+          model: lastModelId ?? model
+        });
+        const toolCalls = contentBlocks.filter(
+          (b) => b.type === "tool"
+        );
+        if (stopReason !== "tool_use" || toolCalls.length === 0) {
+          statusWatcher.stop();
+          const text = getPartialText(contentBlocks);
+          const hasArtifacts = Object.keys(artifacts).length > 0;
+          return {
+            text,
+            messages: thisInvocation(),
+            ...hasArtifacts ? { artifacts } : {}
+          };
+        }
+        log7.info("Tools executing", {
+          requestId,
+          parentToolId,
+          count: toolCalls.length,
+          tools: toolCalls.map((tc) => tc.name)
+        });
+        watchedToolNames = toolCalls.map((tc) => tc.name).join(", ");
+        const results = await Promise.all(
+          toolCalls.map(async (tc) => {
+            if (signal?.aborted) {
+              return {
+                id: tc.id,
+                result: USER_CANCELLED_RESULT,
+                isError: true
+              };
+            }
+            let settle;
+            const resultPromise = new Promise((res) => {
+              settle = (result, isError) => res({ id: tc.id, result, isError });
+            });
+            let toolAbort = new AbortController();
+            const cascadeAbort = () => toolAbort.abort();
+            signal?.addEventListener("abort", cascadeAbort, { once: true });
+            let settled = false;
+            const safeSettle = (result, isError) => {
+              if (settled) {
+                return;
+              }
+              settled = true;
+              signal?.removeEventListener("abort", cascadeAbort);
+              settle(result, isError);
+            };
+            const run2 = async (input) => {
+              try {
+                let result;
+                if (externalTools.has(tc.name) && resolveExternalTool) {
+                  result = await resolveExternalTool(tc.id, tc.name, input);
+                } else {
+                  const onLog = (line) => emit({
+                    type: "tool_input_delta",
+                    id: tc.id,
+                    name: tc.name,
+                    result: line
+                  });
+                  result = await executeTool2(
+                    tc.name,
+                    input,
+                    tc.id,
+                    onLog,
+                    subAgentMessages
+                  );
+                }
+                safeSettle(capToolResult(result), result.startsWith("Error"));
+              } catch (err) {
+                safeSettle(`Error: ${err.message}`, true);
+              }
+            };
+            const entry = {
+              id: tc.id,
+              name: tc.name,
+              input: tc.input,
+              parentToolId,
+              abortController: toolAbort,
+              startedAt: Date.now(),
+              settle: safeSettle,
+              rerun: (newInput) => {
+                settled = false;
+                toolAbort = new AbortController();
+                signal?.addEventListener("abort", () => toolAbort.abort(), {
+                  once: true
                 });
+                entry.abortController = toolAbort;
+                entry.input = newInput;
+                run2(newInput);
               }
-              emit({ type: "text", text: event.text });
-              break;
+            };
+            toolRegistry?.register(entry);
+            const toolStart = Date.now();
+            run2(tc.input);
+            const r = await resultPromise;
+            toolRegistry?.unregister(tc.id);
+            log7.info("Tool completed", {
+              requestId,
+              parentToolId,
+              toolCallId: tc.id,
+              name: tc.name,
+              durationMs: Date.now() - toolStart,
+              isError: r.isError
+            });
+            emit({
+              type: "tool_done",
+              id: tc.id,
+              name: tc.name,
+              result: r.result,
+              isError: r.isError
+            });
+            return r;
+          })
+        );
+        lastToolResult = results.at(-1)?.result ?? "";
+        for (const r of results) {
+          const block = contentBlocks.find(
+            (b) => b.type === "tool" && b.id === r.id
+          );
+          if (block?.type === "tool") {
+            block.result = r.result;
+            block.isError = r.isError;
+            block.completedAt = Date.now();
+            const innerMsgs = subAgentMessages.get(r.id);
+            if (innerMsgs) {
+              block.subAgentMessages = innerMsgs;
             }
-            case "thinking":
-              if (!thinkingStartedAt) {
-                thinkingStartedAt = event.ts;
+            if (captureArtifacts?.includes(block.name) && !r.isError) {
+              try {
+                artifacts[block.name] = JSON.parse(r.result);
+              } catch {
               }
-              emit({ type: "thinking", text: event.text });
-              break;
-            case "thinking_complete":
-              contentBlocks.push({
-                type: "thinking",
-                thinking: event.thinking,
-                signature: event.signature,
-                startedAt: thinkingStartedAt,
-                completedAt: event.ts
-              });
-              lastThinkingRelatedStartedAt = thinkingStartedAt;
-              thinkingStartedAt = 0;
-              break;
-            case "redacted_thinking_complete": {
-              const startedAt = lastThinkingRelatedStartedAt !== void 0 ? lastThinkingRelatedStartedAt + 1 : event.ts;
-              contentBlocks.push({
-                type: "redacted_thinking",
-                data: event.data,
-                startedAt,
-                completedAt: event.ts
-              });
-              lastThinkingRelatedStartedAt = startedAt;
-              break;
             }
-            case "tool_use":
-              contentBlocks.push({
-                type: "tool",
-                id: event.id,
-                name: event.name,
-                input: event.input,
-                startedAt: Date.now()
-              });
-              emit({
-                type: "tool_start",
-                id: event.id,
-                name: event.name,
-                input: event.input
-              });
-              break;
-            case "done":
-              stopReason = event.stopReason;
-              lastUsage = {
-                inputTokens: event.usage.inputTokens,
-                outputTokens: event.usage.outputTokens,
-                cacheCreationTokens: event.usage.cacheCreationTokens,
-                cacheReadTokens: event.usage.cacheReadTokens,
-                llmCalls: 1
-              };
-              lastProviderMetadata = event.providerMetadata;
-              lastModelId = event.modelId;
-              recordUsage({
-                ts: Date.now(),
-                requestId,
-                agentName: subAgentId || "sub-agent",
-                parentToolId,
-                modelId: event.modelId,
-                inputTokens: event.usage.inputTokens,
-                outputTokens: event.usage.outputTokens,
-                cacheCreationTokens: event.usage.cacheCreationTokens,
-                cacheReadTokens: event.usage.cacheReadTokens,
-                cost: nanoToDollars(event.cost),
-                billingEvents: event.billingEvents,
-                durationMs: Date.now() - iterStart,
-                toolNames: contentBlocks.filter(
-                  (b) => b.type === "tool"
-                ).map((b) => b.name)
-              });
-              break;
-            case "error":
-              return {
-                text: `Error: ${event.error}`,
-                messages: thisInvocation()
-              };
           }
-        }
-      } catch (err) {
-        if (!signal?.aborted) {
-          throw err;
+          messages.push({
+            role: "user",
+            content: r.result,
+            toolCallId: r.id,
+            isToolError: r.isError
+          });
         }
       }
-      if (signal?.aborted) {
-        statusWatcher.stop();
-        return abortResult(contentBlocks);
-      }
-      messages.push({
-        role: "assistant",
-        content: contentBlocks,
-        ...lastUsage ? { usage: lastUsage } : {},
-        ...lastProviderMetadata ? { providerMetadata: lastProviderMetadata } : {},
-        model: lastModelId ?? model
+    } finally {
+      statusWatcher.stop();
+    }
+  };
+  const wrapRun = async () => {
+    try {
+      const result = await run();
+      log7.info("Sub-agent complete", {
+        requestId,
+        parentToolId,
+        agentName,
+        durationMs: Date.now() - runStart,
+        turns
       });
-      const toolCalls = contentBlocks.filter(
-        (b) => b.type === "tool"
-      );
-      if (stopReason !== "tool_use" || toolCalls.length === 0) {
-        statusWatcher.stop();
-        const text = getPartialText(contentBlocks);
-        const hasArtifacts = Object.keys(artifacts).length > 0;
-        return {
-          text,
-          messages: thisInvocation(),
-          ...hasArtifacts ? { artifacts } : {}
-        };
-      }
-      log7.info("Tools executing", {
+      return result;
+    } catch (err) {
+      log7.warn("Sub-agent error", {
         requestId,
         parentToolId,
-        count: toolCalls.length,
-        tools: toolCalls.map((tc) => tc.name)
-      });
-      currentToolNames = toolCalls.map((tc) => tc.name).join(", ");
-      const results = await Promise.all(
-        toolCalls.map(async (tc) => {
-          if (signal?.aborted) {
-            return { id: tc.id, result: USER_CANCELLED_RESULT, isError: true };
-          }
-          let settle;
-          const resultPromise = new Promise((res) => {
-            settle = (result, isError) => res({ id: tc.id, result, isError });
-          });
-          let toolAbort = new AbortController();
-          const cascadeAbort = () => toolAbort.abort();
-          signal?.addEventListener("abort", cascadeAbort, { once: true });
-          let settled = false;
-          const safeSettle = (result, isError) => {
-            if (settled) {
-              return;
-            }
-            settled = true;
-            signal?.removeEventListener("abort", cascadeAbort);
-            settle(result, isError);
-          };
-          const run2 = async (input) => {
-            try {
-              let result;
-              if (externalTools.has(tc.name) && resolveExternalTool) {
-                result = await resolveExternalTool(tc.id, tc.name, input);
-              } else {
-                const onLog = (line) => emit({
-                  type: "tool_input_delta",
-                  id: tc.id,
-                  name: tc.name,
-                  result: line
-                });
-                result = await executeTool2(
-                  tc.name,
-                  input,
-                  tc.id,
-                  onLog,
-                  subAgentMessages
-                );
-              }
-              safeSettle(capToolResult(result), result.startsWith("Error"));
-            } catch (err) {
-              safeSettle(`Error: ${err.message}`, true);
-            }
-          };
-          const entry = {
-            id: tc.id,
-            name: tc.name,
-            input: tc.input,
-            parentToolId,
-            abortController: toolAbort,
-            startedAt: Date.now(),
-            settle: safeSettle,
-            rerun: (newInput) => {
-              settled = false;
-              toolAbort = new AbortController();
-              signal?.addEventListener("abort", () => toolAbort.abort(), {
-                once: true
-              });
-              entry.abortController = toolAbort;
-              entry.input = newInput;
-              run2(newInput);
-            }
-          };
-          toolRegistry?.register(entry);
-          const toolStart = Date.now();
-          run2(tc.input);
-          const r = await resultPromise;
-          toolRegistry?.unregister(tc.id);
-          log7.info("Tool completed", {
-            requestId,
-            parentToolId,
-            toolCallId: tc.id,
-            name: tc.name,
-            durationMs: Date.now() - toolStart,
-            isError: r.isError
-          });
-          emit({
-            type: "tool_done",
-            id: tc.id,
-            name: tc.name,
-            result: r.result,
-            isError: r.isError
-          });
-          return r;
-        })
-      );
-      statusWatcher.stop();
-      lastToolResult = results.at(-1)?.result ?? "";
-      for (const r of results) {
-        const block = contentBlocks.find(
-          (b) => b.type === "tool" && b.id === r.id
-        );
-        if (block?.type === "tool") {
-          block.result = r.result;
-          block.isError = r.isError;
-          block.completedAt = Date.now();
-          const innerMsgs = subAgentMessages.get(r.id);
-          if (innerMsgs) {
-            block.subAgentMessages = innerMsgs;
-          }
-          if (captureArtifacts?.includes(block.name) && !r.isError) {
-            try {
-              artifacts[block.name] = JSON.parse(r.result);
-            } catch {
-            }
-          }
-        }
-        messages.push({
-          role: "user",
-          content: r.result,
-          toolCallId: r.id,
-          isToolError: r.isError
-        });
-      }
-    }
-  };
-  const wrapRun = async () => {
-    try {
-      const result = await run();
-      log7.info("Sub-agent complete", {
-        requestId,
-        parentToolId,
-        agentName,
-        durationMs: Date.now() - runStart,
-        turns
-      });
-      return result;
-    } catch (err) {
-      log7.warn("Sub-agent error", {
-        requestId,
-        parentToolId,
-        agentName,
-        error: err.message
+        agentName,
+        error: err.message
       });
       throw err;
     }
@@ -4099,7 +4193,7 @@ var BROWSER_TOOLS = [
                   "screenshotViewport",
                   "setViewport"
                 ],
-                description: 'snapshot: accessibility tree of the page (waits for network to settle). click: click an element (animated cursor, full event sequence). type: type text into input (one char at a time, works with React/Vue/Svelte). select: select a dropdown option by text. wait: wait for an element to appear (polls 100ms, waits for network). navigate: navigate to a URL within the app (waits for load, subsequent steps run on new page). evaluate: run JS in the page. styles: read computed CSS styles from elements (pass properties array with camelCase names, or omit for defaults). screenshotFullPage: screenshot of the whole page top-to-bottom (returns a CDN url with dimensions and a written analysis). screenshotViewport: screenshot of just the visible viewport \u2014 pass `scrollToSelector` (or `scrollY`) on this step to scroll a section into view and capture it in one atomic step (no separate scroll needed). setViewport: switch the browser between desktop and mobile rendering (pass `mode`: "desktop" or "mobile"). Reloads the page so responsive layouts, media queries, and matchMedia re-evaluate \u2014 use it to QA mobile/responsive views.'
+                description: 'snapshot: accessibility tree of the page (waits for network to settle). click: click an element (animated cursor, full event sequence). type: type text into input (one char at a time, works with React/Vue/Svelte). select: select a dropdown option by text. wait: wait for an element to appear (polls 100ms, waits for network). navigate: navigate to a URL within the app (waits for the route, subsequent steps run on the new page; soft in-app route change by default \u2014 pass `fresh: true` for a real full page load; the result reports the URL actually landed on, so app redirects are visible). evaluate: run JS in the page. styles: read computed CSS styles from elements (pass properties array with camelCase names, or omit for defaults). screenshotFullPage: screenshot of the whole page top-to-bottom (returns a CDN url with dimensions and a written analysis). screenshotViewport: screenshot of just the visible viewport \u2014 pass `scrollToSelector` (or `scrollY`) on this step to scroll a section into view and capture it in one atomic step (no separate scroll needed). setViewport: switch the browser between desktop and mobile rendering (pass `mode`: "desktop" or "mobile"). Reloads the page so responsive layouts, media queries, and matchMedia re-evaluate \u2014 use it to QA mobile/responsive views.'
               },
               ref: {
                 type: "string",
@@ -4141,6 +4235,10 @@ var BROWSER_TOOLS = [
                 type: "string",
                 description: 'For navigate: the URL to navigate to (e.g., "/quiz", "/settings").'
               },
+              fresh: {
+                type: "boolean",
+                description: "For navigate: force a real full page load (fresh document) instead of a soft in-app route change. Use when testing what a user sees on entry \u2014 landing pages, join/invite links, signed-out views \u2014 where reusing the SPA\u2019s in-memory state would test the wrong thing."
+              },
               properties: {
                 type: "array",
                 items: { type: "string" },
@@ -5925,6 +6023,122 @@ var codeSanityCheckTool = {
   }
 };
 
+// src/tools/spec/writeBuildOverview.ts
+import fs20 from "fs";
+var OVERVIEW_FILE = "src/overview.html";
+var DESIGN_BRIEF = `We are building the Build Overview for this app \u2014 the home page of its Spec tab. It is a calm, dense, one-page reference of everything the app actually contains, including the parts the user can't see. It renders flush inside the Spec tab's content panel (the IDE supplies the surrounding nav).
+
+Take the plain-language copy in <overview_copy> and lay it out and skin it into a single, beautiful, self-contained HTML document in the app's own brand.
+
+### The single hard rule
+The copy in <overview_copy> is final \u2014 it was authored and edited before it reached you. Treat it as locked content to typeset, not a draft to improve. Reproduce the words exactly: do not rewrite, rephrase, shorten, expand, reorder, or "polish" them, and do not run them through any copy tool. This is the opposite of your usual role \u2014 here you own layout, typography, and visual design only, and the words (every number, name, label, claim, and sentence) are fixed. A single changed word or wrong number breaks this document's purpose.
+
+### What it is (and is not)
+- A typeset reference dossier: composed, dense, a little cool \u2014 substantial at a glance, then readable. Density communicates substance; sparse and airy reads as "not much here."
+- Brand-skinned: pull the palette, type system, and a single accent from the app's spec. The accent leads labels and figures; it is a mark, not a fill.
+- NOT a slide deck \u2014 no theatrics, no building to a climax, no persuasion.
+- NOT a docs site \u2014 no raised or shadowed cards, no hover-lift, no clickable-feeling surfaces, no sticky table of contents.
+- NOT a sparse memo \u2014 a restrained single-column page under-sells the work.
+- No header chrome and no footer: open straight on the app's logo and name so it sits flush with the IDE.
+
+### Constraints
+- A single self-contained HTML file. Fonts may load from a CDN; everything else (CSS, the logo SVG) is inline.
+- Responsive: fills the embedded panel width and collapses gracefully at narrow widths.`;
+var OVERVIEW_SHELL = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<!-- This renders inside an iframe in the IDE. Keep it a simple, self-contained
+     static document \u2014 no scroll/zoom/accessibility scaffolding beyond this head.
+     The user-scalable=no viewport is intentional; leave it. -->
+<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+<title>Build Overview</title>
+<!-- SKIN: link the app's fonts here (CDN \u2014 e.g. Fontshare / Google Fonts). -->
+<style>
+*, *::before, *::after { margin: 0; padding: 0; box-sizing: border-box; }
+</style>
+</head>
+<body>
+<!-- Compose the Build Overview here. Layout, sections, type, and styling are
+     yours \u2014 keep everything inline and self-contained, brand-skinned from the
+     app's spec. -->
+</body>
+</html>`;
+function initialDelivery() {
+  return `### Your deliverable
+Write the complete Build Overview to \`${OVERVIEW_FILE}\`. The file does not exist yet \u2014 start from this scaffold, which carries the technical hygiene for the iframed render context (keep the viewport meta and the reset). Layout, sections, type, and styling are yours to compose.
+
+<overview_shell>
+${OVERVIEW_SHELL}
+</overview_shell>
+
+Then reply with a one-line summary of what you wrote.`;
+}
+function refreshDelivery() {
+  return `### Your deliverable
+The Build Overview already exists at \`${OVERVIEW_FILE}\`. Read it, then update it to reflect <overview_copy>, preserving its established skin \u2014 change only what the copy changed.
+
+Then reply with a one-line summary of what you changed.`;
+}
+async function renderBuildOverview(content, context, opts) {
+  if (!content) {
+    return "Error: writeBuildOverview requires non-empty `content` (the overview copy).";
+  }
+  const exists = fs20.existsSync(OVERVIEW_FILE);
+  const task = `<overview_copy>${content}</overview_copy>
+
+${DESIGN_BRIEF}
+
+${exists ? refreshDelivery() : initialDelivery()}`;
+  try {
+    if (opts.background) {
+      const result2 = await runDesignExpertRender(
+        { task, background: true, reportingName: "writeBuildOverview" },
+        context
+      );
+      context.subAgentMessages?.set(context.toolCallId, result2.messages);
+      return result2.text;
+    }
+    const result = await runDesignExpertRender({ task }, context);
+    context.subAgentMessages?.set(context.toolCallId, result.messages);
+    if (!fs20.existsSync(OVERVIEW_FILE)) {
+      return `Error: the design expert did not write ${OVERVIEW_FILE}. Its reply was:
+${result.text}`;
+    }
+    return `Build overview written to ${OVERVIEW_FILE}. ${result.text}`;
+  } catch (err) {
+    return `Error generating build overview: ${err.message}`;
+  }
+}
+var buildOverviewTool = {
+  definition: {
+    clearable: false,
+    name: "writeBuildOverview",
+    description: "Generate or refresh the Build Overview \u2014 the project's home page in the Spec tab: a single-page, plain-language reference of everything the app actually contains, including the parts the user can't see (data stores, backend operations, access and roles, background jobs, seeded scenarios, the design system). You author the full copy: read the manifest and spec and state, plainly and exactly, what genuinely exists \u2014 real names and accurate counts \u2014 in calm, declarative, present-tense outcome language, with no persuasion or hype. Describe only what exists. Pass the complete copy as `content`; the design expert lays it out and skins it to the app's brand using your copy verbatim \u2014 it typesets your words, it does not rewrite them, so polish the copy before you pass it. Generate it at the end of a build; routine refreshes ride specSync's `refreshBuildOverview` flag instead, so call this directly only for the initial generation or when the user explicitly asks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The full Build Overview copy you authored: everything the app contains, in plain present-tense outcome language, with real names and exact counts. The design expert lays this out and skins it to the brand verbatim \u2014 it styles your words, it does not rewrite them \u2014 so this should be the final copy."
+        }
+      },
+      required: ["content"]
+    }
+  },
+  async execute(input, context) {
+    if (!context) {
+      return "Error: writeBuildOverview requires execution context for design expert delegation";
+    }
+    const content = (input.content ?? "").trim();
+    const background = Boolean(content) && fs20.existsSync(OVERVIEW_FILE);
+    if (background) {
+      input.background = true;
+    }
+    return renderBuildOverview(content, context, { background });
+  }
+};
+
 // src/subagents/specSync/tools.ts
 var SPEC_SYNC_TOOLS = [
   ...COMMON_READ_TOOLS,
@@ -5955,16 +6169,23 @@ ${readAsset(
 </mindstudio_flavored_markdown_spec_docs>`;
 var specSyncTool = {
   backgroundOnly: true,
+  // Fire-and-forget: completion never wakes the agent. The outcome rides the
+  // next real turn as a hidden background_results note instead.
+  backgroundNotify: "passive",
   definition: {
     clearable: false,
     name: "specSync",
-    description: "Reconcile the spec to bring it in line with code changes you have made. Provide a brief, bulleted list of what changed and why; it finds the affected spec sections and updates them to match. Always runs in the background \u2014 it returns immediately and reports back when done.",
+    description: "Reconcile the spec to bring it in line with code changes you have made. Provide a brief, bulleted list of what changed and why; it finds the affected spec sections and updates them to match. Set `refreshBuildOverview` after a deploy or a large milestone to also re-author the Build Overview from the updated spec. Always runs in the background and completes silently \u2014 do not wait for it; its outcome appears as an automated note at the start of a later turn.",
     inputSchema: {
       type: "object",
       properties: {
         task: {
           type: "string",
           description: "What you changed in the code and why, in plain language \u2014 the way you would explain it to a teammate. The specialist reads the spec itself and decides which sections to update; you do not need to name files or spec locations."
+        },
+        refreshBuildOverview: {
+          type: "boolean",
+          description: "Also refresh the Build Overview (src/overview.html) after reconciling \u2014 the specialist authors fresh copy from the updated spec and re-renders the page. Set this after a deploy or a large milestone; leave it off for routine syncs."
         }
       },
       required: ["task"]
@@ -5988,12 +6209,27 @@ var specSyncTool = {
       parts.push(specIndex);
     }
     const system = parts.join("\n\n");
+    const refreshOverview = input.refreshBuildOverview === true;
+    const tools2 = refreshOverview ? [...SPEC_SYNC_TOOLS, buildOverviewTool.definition] : SPEC_SYNC_TOOLS;
+    const task = refreshOverview ? `${input.task}
+
+After reconciling the spec, refresh the Build Overview: author the complete updated copy from the freshly-reconciled spec (follow the writeBuildOverview tool description) and call \`writeBuildOverview\` once with the final copy.` : input.task;
     const result = await runSubAgent({
       system,
-      task: input.task,
-      tools: SPEC_SYNC_TOOLS,
+      task,
+      tools: tools2,
       externalTools: /* @__PURE__ */ new Set(),
-      executeTool: (name, toolInput) => executeTool(name, toolInput, context),
+      executeTool: (name, toolInput, toolCallId, _onLog, sams) => {
+        if (name === "writeBuildOverview") {
+          const childCtx = toolCallId ? { ...deriveContext(context, toolCallId), subAgentMessages: sams } : { ...context, subAgentMessages: sams };
+          return renderBuildOverview(
+            String(toolInput.content ?? "").trim(),
+            childCtx,
+            { background: false }
+          );
+        }
+        return executeTool(name, toolInput, context);
+      },
       apiConfig: context.apiConfig,
       model: resolveModel("specSync", context.models, context.model),
       subAgentId: "specSync",
@@ -6066,119 +6302,9 @@ var scrapeWebUrlTool = {
   }
 };
 
-// src/tools/spec/writeBuildOverview.ts
-import fs20 from "fs";
-var OVERVIEW_FILE = "src/overview.html";
-var DESIGN_BRIEF = `We are building the Build Overview for this app \u2014 the home page of its Spec tab. It is a calm, dense, one-page reference of everything the app actually contains, including the parts the user can't see. It renders flush inside the Spec tab's content panel (the IDE supplies the surrounding nav).
-
-Take the plain-language copy in <overview_copy> and lay it out and skin it into a single, beautiful, self-contained HTML document in the app's own brand.
-
-### The single hard rule
-The copy in <overview_copy> is final \u2014 it was authored and edited before it reached you. Treat it as locked content to typeset, not a draft to improve. Reproduce the words exactly: do not rewrite, rephrase, shorten, expand, reorder, or "polish" them, and do not run them through any copy tool. This is the opposite of your usual role \u2014 here you own layout, typography, and visual design only, and the words (every number, name, label, claim, and sentence) are fixed. A single changed word or wrong number breaks this document's purpose.
-
-### What it is (and is not)
-- A typeset reference dossier: composed, dense, a little cool \u2014 substantial at a glance, then readable. Density communicates substance; sparse and airy reads as "not much here."
-- Brand-skinned: pull the palette, type system, and a single accent from the app's spec. The accent leads labels and figures; it is a mark, not a fill.
-- NOT a slide deck \u2014 no theatrics, no building to a climax, no persuasion.
-- NOT a docs site \u2014 no raised or shadowed cards, no hover-lift, no clickable-feeling surfaces, no sticky table of contents.
-- NOT a sparse memo \u2014 a restrained single-column page under-sells the work.
-- No header chrome and no footer: open straight on the app's logo and name so it sits flush with the IDE.
-
-### Constraints
-- A single self-contained HTML file. Fonts may load from a CDN; everything else (CSS, the logo SVG) is inline.
-- Responsive: fills the embedded panel width and collapses gracefully at narrow widths.`;
-var OVERVIEW_SHELL = `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<!-- This renders inside an iframe in the IDE. Keep it a simple, self-contained
-     static document \u2014 no scroll/zoom/accessibility scaffolding beyond this head.
-     The user-scalable=no viewport is intentional; leave it. -->
-<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
-<title>Build Overview</title>
-<!-- SKIN: link the app's fonts here (CDN \u2014 e.g. Fontshare / Google Fonts). -->
-<style>
-*, *::before, *::after { margin: 0; padding: 0; box-sizing: border-box; }
-</style>
-</head>
-<body>
-<!-- Compose the Build Overview here. Layout, sections, type, and styling are
-     yours \u2014 keep everything inline and self-contained, brand-skinned from the
-     app's spec. -->
-</body>
-</html>`;
-function initialDelivery() {
-  return `### Your deliverable
-Write the complete Build Overview to \`${OVERVIEW_FILE}\`. The file does not exist yet \u2014 start from this scaffold, which carries the technical hygiene for the iframed render context (keep the viewport meta and the reset). Layout, sections, type, and styling are yours to compose.
-
-<overview_shell>
-${OVERVIEW_SHELL}
-</overview_shell>
-
-Then reply with a one-line summary of what you wrote.`;
-}
-function refreshDelivery() {
-  return `### Your deliverable
-The Build Overview already exists at \`${OVERVIEW_FILE}\`. Read it, then update it to reflect <overview_copy>, preserving its established skin \u2014 change only what the copy changed.
-
-Then reply with a one-line summary of what you changed.`;
-}
-var buildOverviewTool = {
-  definition: {
-    clearable: false,
-    name: "writeBuildOverview",
-    description: "Generate or refresh the Build Overview \u2014 the project's home page in the Spec tab: a single-page, plain-language reference of everything the app actually contains, including the parts the user can't see (data stores, backend operations, access and roles, background jobs, seeded scenarios, the design system). You author the full copy: read the manifest and spec and state, plainly and exactly, what genuinely exists \u2014 real names and accurate counts \u2014 in calm, declarative, present-tense outcome language, with no persuasion or hype. Describe only what exists. Pass the complete copy as `content`; the design expert lays it out and skins it to the app's brand using your copy verbatim \u2014 it typesets your words, it does not rewrite them, so polish the copy before you pass it. Generate it at the end of a build and refresh it after meaningful work.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        content: {
-          type: "string",
-          description: "The full Build Overview copy you authored: everything the app contains, in plain present-tense outcome language, with real names and exact counts. The design expert lays this out and skins it to the brand verbatim \u2014 it styles your words, it does not rewrite them \u2014 so this should be the final copy."
-        }
-      },
-      required: ["content"]
-    }
-  },
-  async execute(input, context) {
-    if (!context) {
-      return "Error: writeBuildOverview requires execution context for design expert delegation";
-    }
-    const content = (input.content ?? "").trim();
-    if (!content) {
-      return "Error: writeBuildOverview requires non-empty `content` (the overview copy).";
-    }
-    const exists = fs20.existsSync(OVERVIEW_FILE);
-    const task = `<overview_copy>${content}</overview_copy>
-
-${DESIGN_BRIEF}
-
-${exists ? refreshDelivery() : initialDelivery()}`;
-    try {
-      if (exists) {
-        input.background = true;
-        const result2 = await runDesignExpertRender(
-          { task, background: true, reportingName: "writeBuildOverview" },
-          context
-        );
-        context.subAgentMessages?.set(context.toolCallId, result2.messages);
-        return result2.text;
-      }
-      const result = await runDesignExpertRender({ task }, context);
-      context.subAgentMessages?.set(context.toolCallId, result.messages);
-      if (!fs20.existsSync(OVERVIEW_FILE)) {
-        return `Error: the design expert did not write ${OVERVIEW_FILE}. Its reply was:
-${result.text}`;
-      }
-      return `Build overview written to ${OVERVIEW_FILE}. ${result.text}`;
-    } catch (err) {
-      return `Error generating build overview: ${err.message}`;
-    }
-  }
-};
-
-// src/tools/index.ts
-function deriveContext(parent, toolCallId) {
-  return { ...parent, toolCallId };
+// src/tools/index.ts
+function deriveContext(parent, toolCallId) {
+  return { ...parent, toolCallId };
 }
 var ALL_TOOLS = [
   // Common
@@ -6374,7 +6500,11 @@ function getConversationMessagesForSummary(messages, endIndex) {
       break;
     }
   }
-  return messages.slice(startIdx, endIndex);
+  return messages.slice(startIdx, endIndex).filter(
+    (msg) => !(Array.isArray(msg.content) && msg.content.some(
+      (b) => b.type === "tool" && b.uiOnly
+    ))
+  );
 }
 function getSubAgentMessagesForSummary(messages, subAgentName, endIndex) {
   let checkpointIdx = -1;
@@ -6652,6 +6782,11 @@ import path12 from "path";
 var log10 = createLogger("session");
 var SESSION_FILE = ".remy-session.json";
 var ARCHIVE_DIR = ".logs/sessions";
+function writeFileAtomicSync(file, data) {
+  const tmp = `${file}.tmp`;
+  fs21.writeFileSync(tmp, data, "utf-8");
+  fs21.renameSync(tmp, file);
+}
 var ROTATE_THRESHOLD_BYTES = 32 * 1024 * 1024;
 var RETAIN_TAIL_BYTES = 16 * 1024 * 1024;
 var ARCHIVE_RETENTION_BYTES = 64 * 1024 * 1024;
@@ -6751,7 +6886,7 @@ function archiveMessages(messages, label, models) {
   if (models && Object.keys(models).length > 0) {
     payload.models = models;
   }
-  fs21.writeFileSync(dest, JSON.stringify(payload), "utf-8");
+  writeFileAtomicSync(dest, JSON.stringify(payload));
   archiveCountCache.set(path12.basename(dest), count);
   log10.info("Session archived", { label, dest, messageCount: count });
   pruneArchives();
@@ -6956,7 +7091,7 @@ function saveSession(state) {
     if (Buffer.byteLength(serialized, "utf-8") > ROTATE_THRESHOLD_BYTES && rotate(state)) {
       serialized = JSON.stringify(buildPayload(state));
     }
-    fs21.writeFileSync(SESSION_FILE, serialized, "utf-8");
+    writeFileAtomicSync(SESSION_FILE, serialized);
     log10.info("Session saved", { messageCount: state.messages.length });
   } catch (err) {
     log10.warn("Session save failed", { error: err.message });
@@ -6986,6 +7121,28 @@ function clearSession(state) {
 var log11 = createLogger("compaction:trigger");
 var pending = null;
 var inflightCompaction = null;
+function getInflightCompaction() {
+  return inflightCompaction;
+}
+function summariesOf(result) {
+  const out = [];
+  for (const msg of result.checkpoints) {
+    if (!Array.isArray(msg.content)) {
+      continue;
+    }
+    for (const block of msg.content) {
+      if (block.type === "summary") {
+        out.push({
+          name: block.name,
+          text: block.text,
+          ...block.recent && { recent: block.recent },
+          startedAt: block.startedAt
+        });
+      }
+    }
+  }
+  return out;
+}
 function applyPendingSummaries(state) {
   const drained = pending;
   pending = null;
@@ -7006,6 +7163,25 @@ function applyPendingSummaries(state) {
   });
   saveSession(state);
 }
+var SUMMARY_SECTION_LABELS = {
+  conversation: "Conversation",
+  visualDesignExpert: "Design Agent Thread",
+  productVision: "Roadmap Agent Thread"
+};
+function formatSummariesResult(summaries) {
+  if (summaries === null) {
+    return "A compaction checkpoint was already pending \u2014 no new compaction was needed.";
+  }
+  if (summaries.length === 0) {
+    return "Nothing to compact \u2014 the conversation is already fully summarized.";
+  }
+  if (summaries.length === 1 && summaries[0].name === "conversation") {
+    return summaries[0].text;
+  }
+  return summaries.map((s) => `## ${SUMMARY_SECTION_LABELS[s.name] ?? s.name}
+
+${s.text}`).join("\n\n");
+}
 var listener = null;
 function setCompactionListener(l) {
   listener = l;
@@ -7016,18 +7192,24 @@ function triggerCompaction(state, apiConfig, opts = {}) {
   }
   if (pending) {
     log11.info("Compaction skipped \u2014 a checkpoint is already waiting to apply");
-    return Promise.resolve();
+    return Promise.resolve(null);
   }
-  const { blocking = false, requestId, model } = opts;
-  listener?.({ type: "started", blocking, requestId });
+  const { blocking = false, requestId, model, origin, toolCallId } = opts;
+  listener?.({ type: "started", blocking, requestId, origin, toolCallId });
   inflightCompaction = compactConversation(
     state.messages,
     apiConfig,
     resolveModel("conversationSummarizer", state.models, model)
   ).then((result) => {
     pending = result;
-    listener?.({ type: "complete", requestId });
+    const summaries = summariesOf(result);
+    listener?.({
+      type: "complete",
+      requestId,
+      ...summaries.length > 0 && { summaries }
+    });
     log11.info("Compaction complete");
+    return summaries;
   }).catch((err) => {
     const message = err.message || "Compaction failed";
     listener?.({ type: "complete", error: message, requestId });
@@ -7547,6 +7729,62 @@ function parsePartialJson(jsonString) {
   return parseAny();
 }
 
+// src/automatedActions/resolve.ts
+var NON_ACTION_SENTINELS = /* @__PURE__ */ new Set(["background_results"]);
+function resolveAction(text) {
+  const parsed = parseSentinel(text);
+  if (!parsed) {
+    return null;
+  }
+  const { name: triggerName, remainder } = parsed;
+  if (NON_ACTION_SENTINELS.has(triggerName)) {
+    return null;
+  }
+  let params = {};
+  if (remainder) {
+    try {
+      params = JSON.parse(remainder.split("\n")[0]);
+    } catch {
+    }
+  }
+  let body = readAsset("automatedActions", `${triggerName}.md`);
+  let next;
+  const fmMatch = body.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (fmMatch) {
+    const nextMatch = fmMatch[1].match(/^\s*next:\s*(\w+)\s*$/m);
+    if (nextMatch) {
+      next = nextMatch[1];
+    }
+  }
+  body = body.replace(/^---[\s\S]*?---\s*/, "");
+  for (const [key, value] of Object.entries(params)) {
+    const str = typeof value === "string" ? value : JSON.stringify(value);
+    body = body.replaceAll(`{{${key}}}`, str);
+  }
+  return {
+    message: automatedMessage(triggerName, body),
+    next
+  };
+}
+function getActionChain(startName) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let name = startName;
+  while (name && !seen.has(name)) {
+    seen.add(name);
+    chain.push(name);
+    let body;
+    try {
+      body = readAsset("automatedActions", `${name}.md`);
+    } catch {
+      break;
+    }
+    const fm = body.match(/^---\s*\n([\s\S]*?)\n---/);
+    name = fm?.[1].match(/^\s*next:\s*(\w+)\s*$/m)?.[1];
+  }
+  return chain;
+}
+
 // src/errors.ts
 var patterns = [
   [
@@ -7627,6 +7865,7 @@ async function runTurn(params) {
     onboardingState,
     signal,
     onEvent,
+    takeSteering,
     resolveExternalTool,
     requestId,
     toolRegistry,
@@ -7661,7 +7900,7 @@ async function runTurn(params) {
     onEvent({ type: "error", error: "Empty message" });
     return;
   }
-  for (const entry of keptEntries) {
+  const appendEntry = (entry) => {
     const hasAttachments = (entry.attachments?.length ?? 0) > 0;
     const userMsg = { role: "user", content: entry.text };
     if (entry.hidden) {
@@ -7684,6 +7923,9 @@ async function runTurn(params) {
       ...entry.requestId && { requestId: entry.requestId },
       ...entry.queued && { queued: true }
     });
+  };
+  for (const entry of keptEntries) {
+    appendEntry(entry);
   }
   const isFirstMessage = state.messages.filter((m) => m.role === "user").length === 1;
   const STATUS_EXCLUDED_TOOLS = /* @__PURE__ */ new Set([
@@ -7694,6 +7936,9 @@ async function runTurn(params) {
   let lastCompletedTools = "";
   let lastCompletedInput = "";
   let lastCompletedResult = "";
+  let subAgentText = "";
+  let currentToolNames = "";
+  let contentBlocksRef = [];
   let turnInputTokens = 0;
   let turnOutputTokens = 0;
   let turnCacheCreation = 0;
@@ -7702,283 +7947,330 @@ async function runTurn(params) {
   let lastCallInputTokens = 0;
   let lastCallCacheCreation = 0;
   let lastCallCacheRead = 0;
-  while (true) {
-    let getOrCreateAccumulator2 = function(id, name) {
-      let acc = toolInputAccumulators.get(id);
-      if (!acc) {
-        acc = { name, json: "", started: false, lastEmittedCount: 0 };
-        toolInputAccumulators.set(id, acc);
-      }
-      return acc;
-    };
-    var getOrCreateAccumulator = getOrCreateAccumulator2;
-    if (signal?.aborted) {
-      onEvent({ type: "turn_cancelled" });
-      saveSession(state);
-      return;
-    }
-    const iterStart = Date.now();
-    const contentBlocks = [];
-    const thinkingBlockStartTimes = [];
-    let thinkingCompleteCount = 0;
-    let lastThinkingRelatedStartedAt;
-    let textBlockOpen = false;
-    const toolInputAccumulators = /* @__PURE__ */ new Map();
-    let stopReason = "end_turn";
-    let turnProviderMetadata;
-    let turnModelId;
-    let subAgentText = "";
-    let currentToolNames = "";
-    const statusWatcher = isFirstMessage ? { stop() {
-    }, pause() {
-    }, resume() {
-    } } : startStatusWatcher({
-      apiConfig,
-      getContext: () => {
-        const parts = [];
-        const toolName = currentToolNames || getToolCalls(contentBlocks).filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).at(-1)?.name || lastCompletedTools;
-        if (toolName) {
-          parts.push(`Tool: ${toolName}`);
-        }
-        if (lastCompletedInput) {
-          parts.push(`Tool input: ${lastCompletedInput.slice(-1500)}`);
-        }
-        if (lastCompletedResult) {
-          parts.push(`Tool result: ${lastCompletedResult.slice(-1500)}`);
-        }
-        const text = subAgentText || getTextContent(contentBlocks).slice(-2e3);
-        if (text) {
-          parts.push(`Assistant text: ${text}`);
-        }
-        if (onboardingState && onboardingState !== "onboardingFinished") {
-          parts.push(`Build phase: ${onboardingState}`);
+  const statusWatcher = isFirstMessage ? { stop() {
+  }, pause() {
+  }, resume() {
+  } } : startStatusWatcher({
+    apiConfig,
+    getContext: () => {
+      const parts = [];
+      const toolName = currentToolNames || getToolCalls(contentBlocksRef).filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).at(-1)?.name || lastCompletedTools;
+      if (toolName) {
+        parts.push(`Tool: ${toolName}`);
+      }
+      const toolInput = sanitizeStatusText(lastCompletedInput);
+      if (toolInput) {
+        parts.push(`Tool input: ${toolInput.slice(-1500)}`);
+      }
+      const toolResult = sanitizeStatusText(lastCompletedResult);
+      if (toolResult) {
+        parts.push(`Tool result: ${toolResult.slice(-1500)}`);
+      }
+      const text = subAgentText || getTextContent(contentBlocksRef).slice(-2e3);
+      if (text) {
+        parts.push(`Assistant text: ${text}`);
+      }
+      if (onboardingState && onboardingState !== "onboardingFinished") {
+        parts.push(`Build phase: ${onboardingState}`);
+      }
+      let hasUserSignal = false;
+      for (const entry of keptEntries) {
+        if (entry.hidden) {
+          continue;
         }
-        for (const entry of keptEntries) {
-          const automated = parseSentinel(entry.text);
-          if (automated) {
+        const automated = parseSentinel(entry.text);
+        if (automated) {
+          if (!NON_ACTION_SENTINELS.has(automated.name)) {
             parts.push(`Automated action: ${automated.name}`);
-          } else if (entry.text) {
-            parts.push(`User request: ${entry.text.slice(-500)}`);
+            hasUserSignal = true;
           }
+        } else if (entry.text) {
+          parts.push(`User request: ${entry.text.slice(-500)}`);
+          hasUserSignal = true;
         }
-        return parts.join("\n");
-      },
-      onStatus: (label) => onEvent({ type: "status", message: label }),
-      signal
-    });
-    async function handlePartialInput(acc, id, name, partial) {
-      const tool = getToolByName(name);
-      if (!tool?.streaming) {
-        return;
       }
-      const {
-        contentField = "content",
-        transform,
-        partialInput
-      } = tool.streaming;
-      if (partialInput) {
-        const result = partialInput(partial, acc.lastEmittedCount);
-        if (!result) {
-          return;
-        }
-        acc.lastEmittedCount = result.emittedCount;
-        acc.started = true;
-        onEvent({
-          type: "tool_start",
-          id,
-          name,
-          input: result.input,
-          partial: true
-        });
-        return;
+      if (!hasUserSignal && !toolName && !text) {
+        return "";
       }
-      const content = partial[contentField];
-      if (typeof content !== "string") {
+      return parts.join("\n");
+    },
+    onStatus: (label) => onEvent({ type: "status", message: label }),
+    signal
+  });
+  try {
+    while (true) {
+      let getOrCreateAccumulator2 = function(id, name) {
+        let acc = toolInputAccumulators.get(id);
+        if (!acc) {
+          acc = { name, json: "", started: false, lastEmittedCount: 0 };
+          toolInputAccumulators.set(id, acc);
+        }
+        return acc;
+      };
+      var getOrCreateAccumulator = getOrCreateAccumulator2;
+      if (signal?.aborted) {
+        onEvent({ type: "turn_cancelled" });
+        saveSession(state);
         return;
       }
-      if (!acc.started) {
-        acc.started = true;
-        onEvent({ type: "tool_start", id, name, input: partial });
-      }
-      if (transform) {
-        const result = await transform(partial);
-        if (result === null) {
+      const iterStart = Date.now();
+      const contentBlocks = [];
+      const thinkingBlockStartTimes = [];
+      let thinkingCompleteCount = 0;
+      let lastThinkingRelatedStartedAt;
+      let textBlockOpen = false;
+      const toolInputAccumulators = /* @__PURE__ */ new Map();
+      let stopReason = "end_turn";
+      let turnProviderMetadata;
+      let turnModelId;
+      contentBlocksRef = contentBlocks;
+      subAgentText = "";
+      currentToolNames = "";
+      async function handlePartialInput(acc, id, name, partial) {
+        const tool = getToolByName(name);
+        if (!tool?.streaming) {
           return;
         }
-        onEvent({ type: "tool_input_delta", id, name, result });
-      } else {
-        onEvent({ type: "tool_input_delta", id, name, result: content });
-      }
-    }
-    try {
-      for await (const event of streamChatWithRetry(
-        {
-          ...apiConfig,
-          model: parentModel,
-          requestId,
-          system,
-          messages: cleanMessagesForApi(state.messages),
-          tools: tools2,
-          signal
-        },
-        {
-          onRetry: (attempt) => {
-            onEvent({
-              type: "status",
-              message: `Lost connection, retrying (attempt ${attempt + 2} of 3)`
-            });
+        const {
+          contentField = "content",
+          transform,
+          partialInput
+        } = tool.streaming;
+        if (partialInput) {
+          const result = partialInput(partial, acc.lastEmittedCount);
+          if (!result) {
+            return;
           }
+          acc.lastEmittedCount = result.emittedCount;
+          acc.started = true;
+          onEvent({
+            type: "tool_start",
+            id,
+            name,
+            input: result.input,
+            partial: true
+          });
+          return;
         }
-      )) {
-        if (signal?.aborted) {
-          break;
+        const content = partial[contentField];
+        if (typeof content !== "string") {
+          return;
         }
-        switch (event.type) {
-          case "text": {
-            const lastBlock = contentBlocks.at(-1);
-            if (lastBlock?.type === "text" && textBlockOpen) {
-              lastBlock.text += event.text;
-            } else {
-              contentBlocks.push({
-                type: "text",
-                text: event.text,
-                startedAt: event.ts
-              });
-            }
-            textBlockOpen = true;
-            onEvent({ type: "text", text: event.text });
-            break;
+        if (!acc.started) {
+          acc.started = true;
+          onEvent({ type: "tool_start", id, name, input: partial });
+        }
+        if (transform) {
+          const result = await transform(partial);
+          if (result === null) {
+            return;
           }
-          case "thinking":
-            if (event.text === "") {
-              thinkingBlockStartTimes.push(event.ts);
-              textBlockOpen = false;
+          onEvent({ type: "tool_input_delta", id, name, result });
+        } else {
+          onEvent({ type: "tool_input_delta", id, name, result: content });
+        }
+      }
+      try {
+        for await (const event of streamChatWithRetry(
+          {
+            ...apiConfig,
+            model: parentModel,
+            requestId,
+            system,
+            messages: cleanMessagesForApi(state.messages),
+            tools: tools2,
+            signal
+          },
+          {
+            onRetry: (attempt) => {
+              onEvent({
+                type: "status",
+                message: `Lost connection, retrying (attempt ${attempt + 2} of 3)`
+              });
             }
-            onEvent({ type: "thinking", text: event.text });
-            break;
-          case "thinking_complete": {
-            const startedAt = thinkingBlockStartTimes[thinkingCompleteCount] ?? event.ts;
-            contentBlocks.push({
-              type: "thinking",
-              thinking: event.thinking,
-              signature: event.signature,
-              startedAt,
-              completedAt: event.ts
-            });
-            thinkingCompleteCount++;
-            lastThinkingRelatedStartedAt = startedAt;
-            break;
           }
-          case "redacted_thinking_complete": {
-            const startedAt = lastThinkingRelatedStartedAt !== void 0 ? lastThinkingRelatedStartedAt + 1 : event.ts;
-            contentBlocks.push({
-              type: "redacted_thinking",
-              data: event.data,
-              startedAt,
-              completedAt: event.ts
-            });
-            lastThinkingRelatedStartedAt = startedAt;
+        )) {
+          if (signal?.aborted) {
             break;
           }
-          case "tool_input_delta": {
-            const acc = getOrCreateAccumulator2(event.id, event.name);
-            acc.json += event.delta;
-            try {
-              const partial = parsePartialJson(acc.json);
-              await handlePartialInput(acc, event.id, event.name, partial);
-            } catch {
+          switch (event.type) {
+            case "text": {
+              const lastBlock = contentBlocks.at(-1);
+              if (lastBlock?.type === "text" && textBlockOpen) {
+                lastBlock.text += event.text;
+              } else {
+                contentBlocks.push({
+                  type: "text",
+                  text: event.text,
+                  startedAt: event.ts
+                });
+              }
+              textBlockOpen = true;
+              onEvent({ type: "text", text: event.text });
+              break;
             }
-            break;
-          }
-          case "tool_input_args": {
-            const acc = getOrCreateAccumulator2(event.id, event.name);
-            await handlePartialInput(acc, event.id, event.name, event.args);
-            break;
-          }
-          case "tool_use": {
-            const tool = getToolByName(event.name);
-            contentBlocks.push({
-              type: "tool",
-              id: event.id,
-              name: event.name,
-              input: event.input,
-              startedAt: event.ts,
-              ...(event.input.background || tool?.backgroundOnly) && {
-                background: true
+            case "thinking":
+              if (event.text === "") {
+                thinkingBlockStartTimes.push(event.ts);
+                textBlockOpen = false;
               }
-            });
-            const acc = toolInputAccumulators.get(event.id);
-            const wasStreamed = acc?.started ?? false;
-            const isInputStreaming = !!tool?.streaming?.partialInput;
-            log14.info("Tool received", {
-              requestId,
-              toolCallId: event.id,
-              name: event.name
-            });
-            if (!wasStreamed || isInputStreaming) {
-              onEvent({
-                type: "tool_start",
+              onEvent({ type: "thinking", text: event.text });
+              break;
+            case "thinking_complete": {
+              const startedAt = thinkingBlockStartTimes[thinkingCompleteCount] ?? event.ts;
+              contentBlocks.push({
+                type: "thinking",
+                thinking: event.thinking,
+                signature: event.signature,
+                startedAt,
+                completedAt: event.ts
+              });
+              thinkingCompleteCount++;
+              lastThinkingRelatedStartedAt = startedAt;
+              break;
+            }
+            case "redacted_thinking_complete": {
+              const startedAt = lastThinkingRelatedStartedAt !== void 0 ? lastThinkingRelatedStartedAt + 1 : event.ts;
+              contentBlocks.push({
+                type: "redacted_thinking",
+                data: event.data,
+                startedAt,
+                completedAt: event.ts
+              });
+              lastThinkingRelatedStartedAt = startedAt;
+              break;
+            }
+            case "tool_input_delta": {
+              const acc = getOrCreateAccumulator2(event.id, event.name);
+              acc.json += event.delta;
+              try {
+                const partial = parsePartialJson(acc.json);
+                await handlePartialInput(acc, event.id, event.name, partial);
+              } catch {
+              }
+              break;
+            }
+            case "tool_input_args": {
+              const acc = getOrCreateAccumulator2(event.id, event.name);
+              await handlePartialInput(acc, event.id, event.name, event.args);
+              break;
+            }
+            case "tool_use": {
+              const tool = getToolByName(event.name);
+              contentBlocks.push({
+                type: "tool",
                 id: event.id,
                 name: event.name,
-                input: event.input
+                input: event.input,
+                startedAt: event.ts,
+                ...(event.input.background || tool?.backgroundOnly) && {
+                  background: true
+                }
+              });
+              const acc = toolInputAccumulators.get(event.id);
+              const wasStreamed = acc?.started ?? false;
+              const isInputStreaming = !!tool?.streaming?.partialInput;
+              log14.info("Tool received", {
+                requestId,
+                toolCallId: event.id,
+                name: event.name
               });
+              if (!wasStreamed || isInputStreaming) {
+                onEvent({
+                  type: "tool_start",
+                  id: event.id,
+                  name: event.name,
+                  input: event.input,
+                  // Mirror the content-block stamp above so the live event
+                  // matches what a history reload shows — without it the
+                  // frontend renders background rows as already complete.
+                  ...isBackgroundCall({
+                    name: event.name,
+                    input: event.input
+                  }) && { background: true }
+                });
+              }
+              break;
             }
-            break;
-          }
-          case "done":
-            stopReason = event.stopReason;
-            turnProviderMetadata = event.providerMetadata;
-            turnModelId = event.modelId;
-            turnLlmCalls++;
-            lastCallInputTokens = event.usage.inputTokens;
-            lastCallCacheCreation = event.usage.cacheCreationTokens ?? 0;
-            lastCallCacheRead = event.usage.cacheReadTokens ?? 0;
-            turnInputTokens += lastCallInputTokens;
-            turnOutputTokens += event.usage.outputTokens;
-            turnCacheCreation += lastCallCacheCreation;
-            turnCacheRead += lastCallCacheRead;
-            recordUsage({
-              ts: Date.now(),
-              requestId,
-              agentName: "parent",
-              modelId: event.modelId,
-              inputTokens: event.usage.inputTokens,
-              outputTokens: event.usage.outputTokens,
-              cacheCreationTokens: event.usage.cacheCreationTokens,
-              cacheReadTokens: event.usage.cacheReadTokens,
-              cost: nanoToDollars(event.cost),
-              billingEvents: event.billingEvents,
-              durationMs: Date.now() - iterStart,
-              toolNames: contentBlocks.filter(
-                (b) => b.type === "tool"
-              ).map((b) => b.name)
-            });
-            break;
-          case "error":
-            onEvent({
-              type: "error",
-              error: friendlyError(event.error),
-              ...event.code ? { code: event.code } : {}
-            });
-            return;
-        }
-      }
-    } catch (err) {
-      if (signal?.aborted) {
-      } else {
-        throw err;
-      }
-    }
-    if (signal?.aborted) {
-      statusWatcher.stop();
-      if (contentBlocks.length > 0) {
-        contentBlocks.push({
-          type: "text",
-          text: "\n\n(cancelled)",
-          startedAt: Date.now()
-        });
-        state.messages.push({
-          role: "assistant",
+            case "done":
+              stopReason = event.stopReason;
+              turnProviderMetadata = event.providerMetadata;
+              turnModelId = event.modelId;
+              turnLlmCalls++;
+              lastCallInputTokens = event.usage.inputTokens;
+              lastCallCacheCreation = event.usage.cacheCreationTokens ?? 0;
+              lastCallCacheRead = event.usage.cacheReadTokens ?? 0;
+              turnInputTokens += lastCallInputTokens;
+              turnOutputTokens += event.usage.outputTokens;
+              turnCacheCreation += lastCallCacheCreation;
+              turnCacheRead += lastCallCacheRead;
+              recordUsage({
+                ts: Date.now(),
+                requestId,
+                agentName: "parent",
+                modelId: event.modelId,
+                inputTokens: event.usage.inputTokens,
+                outputTokens: event.usage.outputTokens,
+                cacheCreationTokens: event.usage.cacheCreationTokens,
+                cacheReadTokens: event.usage.cacheReadTokens,
+                cost: nanoToDollars(event.cost),
+                billingEvents: event.billingEvents,
+                durationMs: Date.now() - iterStart,
+                toolNames: contentBlocks.filter(
+                  (b) => b.type === "tool"
+                ).map((b) => b.name)
+              });
+              break;
+            case "error":
+              statusWatcher.stop();
+              onEvent({
+                type: "error",
+                error: friendlyError(event.error),
+                ...event.code ? { code: event.code } : {}
+              });
+              return;
+          }
+        }
+      } catch (err) {
+        if (signal?.aborted) {
+        } else {
+          throw err;
+        }
+      }
+      if (signal?.aborted) {
+        statusWatcher.stop();
+        if (contentBlocks.length > 0) {
+          contentBlocks.push({
+            type: "text",
+            text: "\n\n(cancelled)",
+            startedAt: Date.now()
+          });
+          state.messages.push({
+            role: "assistant",
+            content: [...contentBlocks].sort(
+              (a, b) => a.startedAt - b.startedAt
+            ),
+            usage: {
+              inputTokens: turnInputTokens,
+              outputTokens: turnOutputTokens,
+              cacheCreationTokens: turnCacheCreation || void 0,
+              cacheReadTokens: turnCacheRead || void 0,
+              llmCalls: turnLlmCalls
+            },
+            ...turnProviderMetadata && {
+              providerMetadata: turnProviderMetadata
+            },
+            model: turnModelId ?? parentModel,
+            ...modelOverride && { modelOverride }
+          });
+        }
+        onEvent({ type: "turn_cancelled" });
+        saveSession(state);
+        return;
+      }
+      if (contentBlocks.length > 0) {
+        state.messages.push({
+          role: "assistant",
           content: [...contentBlocks].sort((a, b) => a.startedAt - b.startedAt),
           usage: {
             inputTokens: turnInputTokens,
@@ -7994,217 +8286,212 @@ async function runTurn(params) {
           ...modelOverride && { modelOverride }
         });
       }
-      onEvent({ type: "turn_cancelled" });
-      saveSession(state);
-      return;
-    }
-    if (contentBlocks.length > 0) {
-      state.messages.push({
-        role: "assistant",
-        content: [...contentBlocks].sort((a, b) => a.startedAt - b.startedAt),
-        usage: {
-          inputTokens: turnInputTokens,
-          outputTokens: turnOutputTokens,
-          cacheCreationTokens: turnCacheCreation || void 0,
-          cacheReadTokens: turnCacheRead || void 0,
-          llmCalls: turnLlmCalls
-        },
-        ...turnProviderMetadata && { providerMetadata: turnProviderMetadata },
-        model: turnModelId ?? parentModel,
-        ...modelOverride && { modelOverride }
-      });
-    }
-    const toolCalls = getToolCalls(contentBlocks);
-    if (stopReason !== "tool_use" || toolCalls.length === 0) {
-      statusWatcher.stop();
-      saveSession(state);
-      onEvent({
-        type: "turn_done",
-        stats: {
-          inputTokens: turnInputTokens,
-          outputTokens: turnOutputTokens,
-          cacheCreationTokens: turnCacheCreation || void 0,
-          cacheReadTokens: turnCacheRead || void 0,
-          llmCalls: turnLlmCalls,
-          lastCallInputTokens,
-          lastCallCacheCreation: lastCallCacheCreation || void 0,
-          lastCallCacheRead: lastCallCacheRead || void 0
-        }
-      });
-      return;
-    }
-    log14.info("Tools executing", {
-      requestId,
-      count: toolCalls.length,
-      tools: toolCalls.map((tc) => tc.name)
-    });
-    currentToolNames = toolCalls.filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).map((tc) => tc.name).join(", ");
-    const wrappedOnEvent = (e) => {
-      if ("parentToolId" in e && e.parentToolId) {
-        if (e.type === "text") {
-          subAgentText = e.text;
-        } else if (e.type === "tool_start") {
-          subAgentText = `Using ${e.name}`;
-        }
+      const toolCalls = getToolCalls(contentBlocks);
+      if (stopReason !== "tool_use" || toolCalls.length === 0) {
+        statusWatcher.stop();
+        saveSession(state);
+        onEvent({
+          type: "turn_done",
+          stats: {
+            inputTokens: turnInputTokens,
+            outputTokens: turnOutputTokens,
+            cacheCreationTokens: turnCacheCreation || void 0,
+            cacheReadTokens: turnCacheRead || void 0,
+            llmCalls: turnLlmCalls,
+            lastCallInputTokens,
+            lastCallCacheCreation: lastCallCacheCreation || void 0,
+            lastCallCacheRead: lastCallCacheRead || void 0
+          }
+        });
+        return;
       }
-      onEvent(e);
-    };
-    const subAgentMessages = /* @__PURE__ */ new Map();
-    const results = await Promise.all(
-      toolCalls.map(async (tc) => {
-        if (signal?.aborted) {
-          return { id: tc.id, result: USER_CANCELLED_RESULT, isError: true };
+      log14.info("Tools executing", {
+        requestId,
+        count: toolCalls.length,
+        tools: toolCalls.map((tc) => tc.name)
+      });
+      currentToolNames = toolCalls.filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).map((tc) => tc.name).join(", ");
+      const wrappedOnEvent = (e) => {
+        if ("parentToolId" in e && e.parentToolId) {
+          if (e.type === "text") {
+            subAgentText = e.text;
+          } else if (e.type === "tool_start") {
+            subAgentText = `Using ${e.name}`;
+          }
         }
-        const toolStart = Date.now();
-        let settle;
-        const resultPromise = new Promise((res) => {
-          settle = (result, isError) => res({ id: tc.id, result, isError });
-        });
-        let toolAbort = new AbortController();
-        let settled = false;
-        const safeSettle = (result, isError) => {
-          if (settled) {
-            return;
+        onEvent(e);
+      };
+      const subAgentMessages = /* @__PURE__ */ new Map();
+      const results = await Promise.all(
+        toolCalls.map(async (tc) => {
+          if (signal?.aborted) {
+            return { id: tc.id, result: USER_CANCELLED_RESULT, isError: true };
           }
-          settled = true;
-          signal?.removeEventListener("abort", cascadeAbort);
-          settle(result, isError);
-        };
-        const cascadeAbort = () => {
-          toolAbort.abort();
-          safeSettle(USER_CANCELLED_RESULT, true);
-        };
-        signal?.addEventListener("abort", cascadeAbort, { once: true });
-        const run = async (input) => {
-          try {
-            let result;
-            if (EXTERNAL_TOOLS.has(tc.name) && resolveExternalTool) {
-              saveSession(state);
-              log14.info("Waiting for external tool result", {
-                requestId,
-                toolCallId: tc.id,
-                name: tc.name
-              });
-              const blocksUser = USER_BLOCKING_EXTERNAL_TOOLS.has(tc.name);
-              if (blocksUser) {
-                statusWatcher.pause();
-              }
-              try {
-                result = await resolveExternalTool(tc.id, tc.name, input);
-              } finally {
+          const toolStart = Date.now();
+          let settle;
+          const resultPromise = new Promise((res) => {
+            settle = (result, isError) => res({ id: tc.id, result, isError });
+          });
+          let toolAbort = new AbortController();
+          let settled = false;
+          const safeSettle = (result, isError) => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            signal?.removeEventListener("abort", cascadeAbort);
+            settle(result, isError);
+          };
+          const cascadeAbort = () => {
+            toolAbort.abort();
+            safeSettle(USER_CANCELLED_RESULT, true);
+          };
+          signal?.addEventListener("abort", cascadeAbort, { once: true });
+          const run = async (input) => {
+            try {
+              let result;
+              if (EXTERNAL_TOOLS.has(tc.name) && resolveExternalTool) {
+                saveSession(state);
+                log14.info("Waiting for external tool result", {
+                  requestId,
+                  toolCallId: tc.id,
+                  name: tc.name
+                });
+                const blocksUser = USER_BLOCKING_EXTERNAL_TOOLS.has(tc.name);
                 if (blocksUser) {
-                  statusWatcher.resume();
+                  statusWatcher.pause();
+                }
+                try {
+                  result = await resolveExternalTool(tc.id, tc.name, input);
+                } finally {
+                  if (blocksUser) {
+                    statusWatcher.resume();
+                  }
                 }
+              } else {
+                result = await executeTool(tc.name, input, {
+                  apiConfig,
+                  model,
+                  models: state.models,
+                  signal: toolAbort.signal,
+                  onEvent: wrappedOnEvent,
+                  resolveExternalTool,
+                  toolCallId: tc.id,
+                  requestId,
+                  onboardingState,
+                  subAgentMessages,
+                  conversationMessages: state.messages,
+                  toolRegistry,
+                  onBackgroundComplete,
+                  onLog: (line) => wrappedOnEvent({
+                    type: "tool_input_delta",
+                    id: tc.id,
+                    name: tc.name,
+                    result: line
+                  })
+                });
               }
-            } else {
-              result = await executeTool(tc.name, input, {
-                apiConfig,
-                model,
-                models: state.models,
-                signal: toolAbort.signal,
-                onEvent: wrappedOnEvent,
-                resolveExternalTool,
-                toolCallId: tc.id,
-                requestId,
-                onboardingState,
-                subAgentMessages,
-                conversationMessages: state.messages,
-                toolRegistry,
-                onBackgroundComplete,
-                onLog: (line) => wrappedOnEvent({
-                  type: "tool_input_delta",
-                  id: tc.id,
-                  name: tc.name,
-                  result: line
-                })
+              safeSettle(capToolResult(result), result.startsWith("Error"));
+            } catch (err) {
+              safeSettle(`Error: ${err.message}`, true);
+            }
+          };
+          const entry = {
+            id: tc.id,
+            name: tc.name,
+            input: tc.input,
+            abortController: toolAbort,
+            startedAt: toolStart,
+            settle: safeSettle,
+            rerun: (newInput) => {
+              settled = false;
+              toolAbort = new AbortController();
+              signal?.addEventListener("abort", () => toolAbort.abort(), {
+                once: true
               });
+              entry.abortController = toolAbort;
+              entry.input = newInput;
+              run(newInput);
             }
-            safeSettle(capToolResult(result), result.startsWith("Error"));
-          } catch (err) {
-            safeSettle(`Error: ${err.message}`, true);
+          };
+          toolRegistry?.register(entry);
+          run(tc.input);
+          const r = await resultPromise;
+          if (!isBackgroundCall(tc)) {
+            toolRegistry?.unregister(tc.id);
           }
-        };
-        const entry = {
-          id: tc.id,
-          name: tc.name,
-          input: tc.input,
-          abortController: toolAbort,
-          startedAt: toolStart,
-          settle: safeSettle,
-          rerun: (newInput) => {
-            settled = false;
-            toolAbort = new AbortController();
-            signal?.addEventListener("abort", () => toolAbort.abort(), {
-              once: true
-            });
-            entry.abortController = toolAbort;
-            entry.input = newInput;
-            run(newInput);
+          log14.info("Tool completed", {
+            requestId,
+            toolCallId: tc.id,
+            name: tc.name,
+            durationMs: Date.now() - toolStart,
+            isError: r.isError
+          });
+          onEvent({
+            type: "tool_done",
+            id: tc.id,
+            name: tc.name,
+            result: r.result,
+            isError: r.isError
+          });
+          if (!r.isError && BRAND_TRIGGERING_TOOLS.has(tc.name)) {
+            triggerBrandExtraction(
+              apiConfig,
+              resolveModel("brandExtractor", state.models, model)
+            );
+          }
+          return r;
+        })
+      );
+      for (const r of results) {
+        const block = contentBlocks.find(
+          (b) => b.type === "tool" && b.id === r.id
+        );
+        if (block?.type === "tool") {
+          block.result = r.result;
+          block.isError = r.isError;
+          block.completedAt = Date.now();
+          const msgs = subAgentMessages.get(r.id);
+          if (msgs) {
+            block.subAgentMessages = msgs;
           }
-        };
-        toolRegistry?.register(entry);
-        run(tc.input);
-        const r = await resultPromise;
-        if (!isBackgroundCall(tc)) {
-          toolRegistry?.unregister(tc.id);
-        }
-        log14.info("Tool completed", {
-          requestId,
-          toolCallId: tc.id,
-          name: tc.name,
-          durationMs: Date.now() - toolStart,
-          isError: r.isError
-        });
-        onEvent({
-          type: "tool_done",
-          id: tc.id,
-          name: tc.name,
-          result: r.result,
-          isError: r.isError
-        });
-        if (!r.isError && BRAND_TRIGGERING_TOOLS.has(tc.name)) {
-          triggerBrandExtraction(
-            apiConfig,
-            resolveModel("brandExtractor", state.models, model)
-          );
         }
-        return r;
-      })
-    );
-    statusWatcher.stop();
-    for (const r of results) {
-      const block = contentBlocks.find(
-        (b) => b.type === "tool" && b.id === r.id
+      }
+      const lastNonExcluded = toolCalls.filter(
+        (tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)
       );
-      if (block?.type === "tool") {
-        block.result = r.result;
-        block.isError = r.isError;
-        block.completedAt = Date.now();
-        const msgs = subAgentMessages.get(r.id);
-        if (msgs) {
-          block.subAgentMessages = msgs;
+      lastCompletedTools = lastNonExcluded.map((tc) => tc.name).join(", ");
+      lastCompletedInput = JSON.stringify(lastNonExcluded.at(-1)?.input ?? {});
+      lastCompletedResult = results.at(-1)?.result ?? "";
+      for (const r of results) {
+        state.messages.push({
+          role: "user",
+          content: r.result,
+          toolCallId: r.id,
+          isToolError: r.isError
+        });
+      }
+      if (takeSteering && !signal?.aborted) {
+        const injected = (await takeSteering()).filter(
+          (e) => e.text.trim().length > 0 || (e.attachments?.length ?? 0) > 0
+        );
+        if (injected.length > 0) {
+          for (const entry of injected) {
+            appendEntry(entry);
+            keptEntries.push(entry);
+          }
+          saveSession(state);
         }
       }
+      if (signal?.aborted) {
+        statusWatcher.stop();
+        onEvent({ type: "turn_cancelled" });
+        saveSession(state);
+        return;
+      }
     }
-    const lastNonExcluded = toolCalls.filter(
-      (tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)
-    );
-    lastCompletedTools = lastNonExcluded.map((tc) => tc.name).join(", ");
-    lastCompletedInput = JSON.stringify(lastNonExcluded.at(-1)?.input ?? {});
-    lastCompletedResult = results.at(-1)?.result ?? "";
-    for (const r of results) {
-      state.messages.push({
-        role: "user",
-        content: r.result,
-        toolCallId: r.id,
-        isToolError: r.isError
-      });
-    }
-    if (signal?.aborted) {
-      onEvent({ type: "turn_cancelled" });
-      saveSession(state);
-      return;
-    }
+  } finally {
+    statusWatcher.stop();
   }
 }
 
@@ -8375,13 +8662,24 @@ function loadQueue() {
   }
   return [];
 }
-function writeStats(stats, queue) {
+function loadPassiveResults() {
+  try {
+    const stats = JSON.parse(readFileSync2(STATS_FILE, "utf-8"));
+    if (Array.isArray(stats.passiveResults)) {
+      return stats.passiveResults;
+    }
+  } catch {
+  }
+  return [];
+}
+function writeStats(stats, queue, passiveResults) {
   try {
     writeFileSync2(
       STATS_FILE,
       JSON.stringify({
         ...stats,
-        queue
+        queue,
+        passiveResults
       })
     );
   } catch {
@@ -8445,6 +8743,21 @@ var MessageQueue = class {
     }
     return removed;
   }
+  /**
+   * Change a queued item's delivery semantics, keyed by its command
+   * requestId. Fires onChange (→ persist + queue_changed) on success.
+   * Returns the item, or undefined if no queued item matches (e.g. it was
+   * already consumed).
+   */
+  setDelivery(id, delivery) {
+    const item = this.items.find((it) => it.command.requestId === id);
+    if (!item) {
+      return void 0;
+    }
+    item.delivery = delivery;
+    this.onChange?.();
+    return item;
+  }
   /** Copy of current queue contents (for surfacing on events). */
   snapshot() {
     return [...this.items];
@@ -8462,62 +8775,6 @@ var MessageQueue = class {
   }
 };
 
-// src/automatedActions/resolve.ts
-var NON_ACTION_SENTINELS = /* @__PURE__ */ new Set(["background_results"]);
-function resolveAction(text) {
-  const parsed = parseSentinel(text);
-  if (!parsed) {
-    return null;
-  }
-  const { name: triggerName, remainder } = parsed;
-  if (NON_ACTION_SENTINELS.has(triggerName)) {
-    return null;
-  }
-  let params = {};
-  if (remainder) {
-    try {
-      params = JSON.parse(remainder.split("\n")[0]);
-    } catch {
-    }
-  }
-  let body = readAsset("automatedActions", `${triggerName}.md`);
-  let next;
-  const fmMatch = body.match(/^---\s*\n([\s\S]*?)\n---/);
-  if (fmMatch) {
-    const nextMatch = fmMatch[1].match(/^\s*next:\s*(\w+)\s*$/m);
-    if (nextMatch) {
-      next = nextMatch[1];
-    }
-  }
-  body = body.replace(/^---[\s\S]*?---\s*/, "");
-  for (const [key, value] of Object.entries(params)) {
-    const str = typeof value === "string" ? value : JSON.stringify(value);
-    body = body.replaceAll(`{{${key}}}`, str);
-  }
-  return {
-    message: automatedMessage(triggerName, body),
-    next
-  };
-}
-function getActionChain(startName) {
-  const chain = [];
-  const seen = /* @__PURE__ */ new Set();
-  let name = startName;
-  while (name && !seen.has(name)) {
-    seen.add(name);
-    chain.push(name);
-    let body;
-    try {
-      body = readAsset("automatedActions", `${name}.md`);
-    } catch {
-      break;
-    }
-    const fm = body.match(/^---\s*\n([\s\S]*?)\n---/);
-    name = fm?.[1].match(/^\s*next:\s*(\w+)\s*$/m)?.[1];
-  }
-  return chain;
-}
-
 // src/headless/index.ts
 var log16 = createLogger("headless");
 var EXTERNAL_TOOL_TIMEOUT_MS = 3e5;
@@ -8559,11 +8816,27 @@ var HeadlessSession = class {
    * to .remy-stats.json so queued work survives process restarts.
    */
   queue;
+  /**
+   * Holding pen for passive background results (tools with
+   * `backgroundNotify: 'passive'`, e.g. specSync). Deliberately outside the
+   * message queue: pen contents never initiate a turn, never latch the
+   * sandbox's queue-derived busy state, and never trigger resume-on-restart.
+   * Swept into the next real turn as a hidden background_results entry.
+   * Persisted to .remy-stats.json alongside the queue.
+   */
+  passivePen = [];
   // External tool bridge
   pendingTools = /* @__PURE__ */ new Map();
   earlyResults = /* @__PURE__ */ new Map();
   // Tool block updates from background completions (separate from the message queue)
   pendingBlockUpdates = [];
+  /**
+   * Id of the UI-only tool block synthesized for the in-flight user/gate
+   * compaction (see the compaction listener). Model-invoked compactions have
+   * a real block and never set this. Single slot — triggerCompaction is
+   * single-flight.
+   */
+  syntheticCompactionId = null;
   // Tool lifecycle management — shared across all nesting depths
   toolRegistry = new ToolRegistry();
   // IO — accumulates stdin bytes between newline boundaries
@@ -8594,6 +8867,8 @@ var HeadlessSession = class {
       this.persistStats();
       this.emit("queue_changed", { queuedMessages: this.queue.snapshot() });
     });
+    this.passivePen = loadPassiveResults();
+    this.persistStats();
     if (resumed) {
       this.emit("session_restored", {
         messageCount: this.state.messages.length,
@@ -8616,15 +8891,61 @@ var HeadlessSession = class {
         );
         this.sessionStats.compactionInProgress = true;
         this.persistStats();
+        if (!event.toolCallId && (event.origin === "user" || event.origin === "gate")) {
+          const id = `compact_${Date.now()}`;
+          this.syntheticCompactionId = id;
+          this.state.messages.push({
+            role: "assistant",
+            content: [
+              {
+                type: "tool",
+                id,
+                name: "compactConversation",
+                input: {},
+                startedAt: Date.now(),
+                background: true,
+                uiOnly: true,
+                result: "Compaction started in the background."
+              }
+            ]
+          });
+          saveSession(this.state);
+          this.onEvent({
+            type: "tool_start",
+            id,
+            name: "compactConversation",
+            input: {},
+            background: true
+          });
+          this.onEvent({
+            type: "tool_done",
+            id,
+            name: "compactConversation",
+            result: "Compaction started in the background.",
+            isError: false
+          });
+        }
       } else {
         const data = event.error ? { error: event.error } : {};
         this.emit("compaction_complete", data, event.requestId);
+        if (this.syntheticCompactionId) {
+          const id = this.syntheticCompactionId;
+          this.syntheticCompactionId = null;
+          this.onBackgroundComplete(
+            id,
+            "compactConversation",
+            event.error ? `Error: ${event.error}` : formatSummariesResult(event.summaries ?? [])
+          );
+        }
         this.sessionStats.compactionInProgress = false;
         if (!event.error) {
           this.sessionStats.lastContextSize = 0;
         }
         this.sessionStats.messageCount = this.state.messages.length;
         this.persistStats();
+        if (!this.running) {
+          this.kickDrain();
+        }
       }
     });
     process.stdin.setEncoding("utf-8");
@@ -8705,10 +9026,10 @@ var HeadlessSession = class {
   //////////////////////////////////////////////////////////////////////////////
   // Stats + queue persistence
   //////////////////////////////////////////////////////////////////////////////
-  /** Persist sessionStats + queue snapshot to .remy-stats.json. */
+  /** Persist sessionStats + queue snapshot + passive pen to .remy-stats.json. */
   persistStats() {
     this.sessionStats.updatedAt = Date.now();
-    writeStats(this.sessionStats, this.queue.snapshot());
+    writeStats(this.sessionStats, this.queue.snapshot(), this.passivePen);
   }
   //////////////////////////////////////////////////////////////////////////////
   // Background completions (tool-block mutation; message delivery via queue)
@@ -8763,17 +9084,20 @@ var HeadlessSession = class {
       await triggerCompaction(this.state, this.config, {
         blocking: true,
         requestId,
-        model: this.opts.model
+        model: this.opts.model,
+        origin: "gate"
       });
       applyPendingSummaries(this.state);
     } catch {
     }
   }
   onBackgroundComplete = (toolCallId, name, result, subAgentMessages) => {
+    const notify = getToolByName(name)?.backgroundNotify ?? "wake";
     this.pendingBlockUpdates.push({ toolCallId, result, subAgentMessages });
     log16.info("Background complete", {
       toolCallId,
       name,
+      notify,
       requestId: this.currentRequestId
     });
     this.onEvent({
@@ -8782,6 +9106,20 @@ var HeadlessSession = class {
       name,
       result
     });
+    if (notify === "passive") {
+      this.passivePen.push({ toolCallId, name, result });
+      this.persistStats();
+      if (!this.running) {
+        this.applyPendingBlockUpdates();
+      }
+      return;
+    }
+    if (notify === "silent") {
+      if (!this.running) {
+        this.applyPendingBlockUpdates();
+      }
+      return;
+    }
     this.queue.push({
       command: {
         action: "message",
@@ -8850,7 +9188,10 @@ var HeadlessSession = class {
             ...e.attachments && { attachments: e.attachments },
             // Queue-delivered entries are flagged so the frontend renders the
             // echo (idle sends are rendered optimistically instead).
-            ...e.queued && { queued: true }
+            ...e.queued && { queued: true },
+            // Hidden entries (e.g. the passive background_results sweep) are
+            // flagged so the sandbox/frontend suppress the bubble.
+            ...e.hidden && { hidden: true }
           },
           // A merged turn emits one user_message per absorbed entry — each
           // carries its own original requestId, not the turn's.
@@ -9160,6 +9501,43 @@ var HeadlessSession = class {
     this.completedEmitted = false;
     this.lastCompleted = null;
     this.turnStart = Date.now();
+    const inflight2 = getInflightCompaction();
+    if (inflight2) {
+      await inflight2.catch(() => {
+      });
+    }
+    applyPendingSummaries(this.state);
+    if (this.passivePen.length > 0) {
+      const swept = this.passivePen.splice(0);
+      this.persistStats();
+      entries.unshift({
+        text: buildBackgroundResultsMessage(swept),
+        hidden: true
+      });
+    }
+    const consumedRids = [];
+    const takeSteering = async () => {
+      const items = this.queue.removeWhere(
+        (it) => it.source === "user" && it.delivery === "asap" && !this.isDrainBarrier(it)
+      );
+      const steered = [];
+      for (const it of items) {
+        const attachments = it.command.attachments;
+        const attachmentHeader = await this.persistEntryAttachments(attachments);
+        const rid = it.command.requestId;
+        if (rid) {
+          consumedRids.push(rid);
+        }
+        steered.push({
+          text: it.command.text ?? "",
+          attachments,
+          attachmentHeader,
+          requestId: rid,
+          queued: true
+        });
+      }
+      return steered;
+    };
     await this.runForcedCompactionIfNeeded(requestId);
     try {
       await runTurn({
@@ -9173,6 +9551,7 @@ var HeadlessSession = class {
         requestId,
         signal: this.currentAbort.signal,
         onEvent: this.onEvent,
+        takeSteering,
         resolveExternalTool: this.resolveExternalTool,
         toolRegistry: this.toolRegistry,
         onBackgroundComplete: this.onBackgroundComplete
@@ -9202,7 +9581,7 @@ var HeadlessSession = class {
       });
     }
     const outcome = this.primaryOutcome();
-    for (const rid of absorbedRids) {
+    for (const rid of [...absorbedRids, ...consumedRids]) {
       this.emit(
         "completed",
         {
@@ -9217,7 +9596,7 @@ var HeadlessSession = class {
     this.applyPendingBlockUpdates();
   }
   async handleMessage(parsed, requestId) {
-    if (this.running) {
+    if (this.running || getInflightCompaction()) {
       const command = { ...parsed };
       if (requestId && command.requestId === void 0) {
         command.requestId = requestId;
@@ -9227,6 +9606,9 @@ var HeadlessSession = class {
         source: "user",
         enqueuedAt: Date.now()
       });
+      if (!this.running && !getInflightCompaction()) {
+        this.kickDrain();
+      }
       return;
     }
     this.running = true;
@@ -9234,6 +9616,7 @@ var HeadlessSession = class {
       await this.runSingleTurn(parsed, requestId);
       await this.drainQueueLoop();
     } finally {
+      this.currentAbort?.abort();
       this.currentAbort = null;
       this.currentRequestId = void 0;
       this.running = false;
@@ -9265,6 +9648,18 @@ var HeadlessSession = class {
   async drainQueueLoop() {
     while (this.queue.length > 0) {
       const head = this.queue.peek();
+      if (head.command.action === "compact") {
+        this.queue.shift();
+        await triggerCompaction(this.state, this.config, {
+          blocking: true,
+          requestId: head.command.requestId,
+          model: this.opts.model,
+          origin: "user"
+        }).catch(() => {
+        });
+        applyPendingSummaries(this.state);
+        continue;
+      }
       if (head.source === "chain") {
         const item = this.queue.shift();
         const rid = item.command.requestId ?? `chain-${Date.now()}`;
@@ -9309,6 +9704,7 @@ var HeadlessSession = class {
     try {
       await this.drainQueueLoop();
     } finally {
+      this.currentAbort?.abort();
       this.currentAbort = null;
       this.currentRequestId = void 0;
       this.running = false;
@@ -9497,6 +9893,33 @@ var HeadlessSession = class {
       );
       return;
     }
+    if (action === "setQueuedDelivery") {
+      const id = parsed.id;
+      const delivery = parsed.delivery;
+      if (!id || delivery !== "asap" && delivery !== "afterTurn") {
+        this.emit(
+          "completed",
+          {
+            success: false,
+            error: 'setQueuedDelivery requires id and delivery ("asap" | "afterTurn")'
+          },
+          requestId
+        );
+        return;
+      }
+      const target = this.queue.snapshot().find((it) => it.command.requestId === id);
+      if (!target || target.source !== "user" || this.isDrainBarrier(target)) {
+        this.emit(
+          "completed",
+          { success: false, error: "message not found or not promotable" },
+          requestId
+        );
+        return;
+      }
+      this.queue.setDelivery(id, delivery);
+      this.emit("completed", { success: true }, requestId);
+      return;
+    }
     if (action === "stop_tool") {
       const id = parsed.id;
       const mode = parsed.mode ?? "hard";
@@ -9528,11 +9951,31 @@ var HeadlessSession = class {
       return;
     }
     if (action === "compact") {
+      if (this.running) {
+        const alreadyQueued = this.queue.snapshot().some((it) => it.command.action === "compact");
+        if (!alreadyQueued) {
+          this.queue.push({
+            command: {
+              action: "compact",
+              // Display label for the queue card (matches the automated
+              // action idiom); never resolved as an action — drainQueueLoop
+              // routes on command.action before any sentinel handling.
+              text: sentinel("compact"),
+              requestId
+            },
+            source: "user",
+            enqueuedAt: Date.now()
+          });
+        }
+        this.emit("completed", { success: true, queued: true }, requestId);
+        return;
+      }
       try {
         await triggerCompaction(this.state, this.config, {
           blocking: false,
           requestId,
-          model: this.opts.model
+          model: this.opts.model,
+          origin: "user"
         });
         if (!this.running) {
           applyPendingSummaries(this.state);