@mindstudio-ai/remy 0.1.337 → 0.1.339

package/dist/index.js

@@ -4949,127 +4949,6 @@ ${partial}` : "[INTERRUPTED] Tool execution was stopped.";
   }
 });
 
-// src/statusWatcher.ts
-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();
-      if (!context) {
-        return;
-      }
-      const res = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiConfig.apiKey}`,
-          // Also a liveness signal for this box, and the most frequent one there is — this ticks
-          // every few seconds for as long as the agent is working, which is exactly the window in
-          // which the user may have backgrounded the tab and stopped its own keepalive.
-          ...sandboxSessionHeader()
-        },
-        body: JSON.stringify({ appId: apiConfig.appId, context }),
-        signal
-      });
-      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;
-    }
-  }
-  const timer = setInterval(tick, interval);
-  tick().catch(() => {
-  });
-  return {
-    stop() {
-      stopped = true;
-      clearInterval(timer);
-    },
-    pause() {
-      pauseCount++;
-    },
-    resume() {
-      pauseCount = Math.max(0, pauseCount - 1);
-    }
-  };
-}
-var INTERNAL_PAYLOAD_MARKERS;
-var init_statusWatcher = __esm({
-  "src/statusWatcher.ts"() {
-    "use strict";
-    init_api();
-    INTERNAL_PAYLOAD_MARKERS = [
-      "[USER CANCELLED]",
-      "[INTERRUPTED]",
-      "[INTERRUPTED - PARTIAL OUTPUT RETRIEVED]",
-      "<background_results>",
-      "<workspace_status>",
-      "<tool_result"
-    ];
-  }
-});
-
 // src/subagents/runner.ts
 async function runSubAgent(config) {
   const {
@@ -5137,376 +5016,339 @@ ${partial}` : "[INTERRUPTED] Agent was interrupted before producing output.",
       }
       return { text: cancelledToolResult(signal), messages: thisInvocation() };
     }
-    let lastToolResult = "";
-    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,
-              cachePolicy,
-              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;
+    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;
+      try {
+        for await (const event of streamChatWithRetry(
+          {
+            ...apiConfig,
+            model,
+            requestId,
+            subAgentId,
+            system: fullSystem,
+            messages: cleanMessagesForApi(messages),
+            tools: tools2,
+            cachePolicy,
+            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: "redacted_thinking",
-                  data: event.data,
-                  startedAt,
-                  completedAt: event.ts
+                  type: "text",
+                  text: event.text,
+                  startedAt: 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()
-                };
+              emit({ type: "text", text: event.text });
+              break;
             }
-          }
-        } catch (err) {
-          if (!signal?.aborted) {
-            throw err;
-          }
-        }
-        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) {
-          let text = getPartialText(contentBlocks);
-          if (validateResult) {
-            let objection = null;
-            try {
-              objection = await validateResult(text, thisInvocation());
-            } catch (err) {
-              log8.warn("Result validator failed, accepting response", {
-                requestId,
-                parentToolId,
-                agentName,
-                error: err.message
+            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;
             }
-            if (objection && !validationRetried && !signal?.aborted) {
-              validationRetried = true;
-              log8.info("Result rejected by validator, retrying once", {
-                requestId,
-                parentToolId,
-                agentName,
-                objection: objection.slice(0, 200)
+            case "tool_use":
+              contentBlocks.push({
+                type: "tool",
+                id: event.id,
+                name: event.name,
+                input: event.input,
+                startedAt: Date.now()
               });
               emit({
-                type: "status",
-                message: "Response failed validation, revising"
+                type: "tool_start",
+                id: event.id,
+                name: event.name,
+                input: event.input
               });
-              messages.push({ role: "user", content: objection });
-              continue;
-            }
-            if (objection) {
-              text = `${text}
-
-[Response validator: ${objection}]`;
-            }
-          }
-          statusWatcher.stop();
-          const hasArtifacts = Object.keys(artifacts).length > 0;
-          return {
-            text,
-            messages: thisInvocation(),
-            ...hasArtifacts ? { artifacts } : {}
-          };
-        }
-        log8.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: cancelledToolResult(signal),
-                isError: true
+              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
               };
-            }
-            let settle;
-            const resultPromise = new Promise((res) => {
-              settle = (result, isError, recording) => res({
-                id: tc.id,
-                result,
-                isError,
-                ...recording ? { recording } : {}
+              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)
               });
-            });
-            let toolAbort = new AbortController();
-            const cascadeAbort = () => toolAbort.abort();
-            signal?.addEventListener("abort", cascadeAbort, { once: true });
-            let settled = false;
-            const safeSettle = (result, isError, recording) => {
-              if (settled) {
-                return;
-              }
-              settled = true;
-              signal?.removeEventListener("abort", cascadeAbort);
-              settle(result, isError, recording);
-            };
-            const run2 = async (input) => {
-              try {
-                let result;
-                let recording;
-                if (externalTools.has(tc.name) && resolveExternalTool) {
-                  result = await resolveExternalTool(tc.id, tc.name, input);
-                  if (tc.name === "browserCommand") {
-                    const lifted = liftRecording(result);
-                    result = lifted.result;
-                    recording = lifted.recording;
-                  }
-                } 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"),
-                  recording
-                );
-              } catch (err) {
-                safeSettle(`Error: ${err.message}`, true);
-              }
-            };
-            const entry = {
-              id: tc.id,
-              name: tc.name,
-              input: tc.input,
+              break;
+            case "error":
+              return {
+                text: `Error: ${event.error}`,
+                messages: thisInvocation()
+              };
+          }
+        }
+      } catch (err) {
+        if (!signal?.aborted) {
+          throw err;
+        }
+      }
+      if (signal?.aborted) {
+        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) {
+        let text = getPartialText(contentBlocks);
+        if (validateResult) {
+          let objection = null;
+          try {
+            objection = await validateResult(text, thisInvocation());
+          } catch (err) {
+            log8.warn("Result validator failed, accepting response", {
+              requestId,
               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);
-            log8.info("Tool completed", {
+              agentName,
+              error: err.message
+            });
+          }
+          if (objection && !validationRetried && !signal?.aborted) {
+            validationRetried = true;
+            log8.info("Result rejected by validator, retrying once", {
               requestId,
               parentToolId,
-              toolCallId: tc.id,
-              name: tc.name,
-              durationMs: Date.now() - toolStart,
-              isError: r.isError
+              agentName,
+              objection: objection.slice(0, 200)
             });
             emit({
-              type: "tool_done",
+              type: "status",
+              message: "Response failed validation, revising"
+            });
+            messages.push({ role: "user", content: objection });
+            continue;
+          }
+          if (objection) {
+            text = `${text}
+
+[Response validator: ${objection}]`;
+          }
+        }
+        const hasArtifacts = Object.keys(artifacts).length > 0;
+        return {
+          text,
+          messages: thisInvocation(),
+          ...hasArtifacts ? { artifacts } : {}
+        };
+      }
+      log8.info("Tools executing", {
+        requestId,
+        parentToolId,
+        count: toolCalls.length,
+        tools: toolCalls.map((tc) => tc.name)
+      });
+      const results = await Promise.all(
+        toolCalls.map(async (tc) => {
+          if (signal?.aborted) {
+            return {
+              id: tc.id,
+              result: cancelledToolResult(signal),
+              isError: true
+            };
+          }
+          let settle;
+          const resultPromise = new Promise((res) => {
+            settle = (result, isError, recording) => res({
               id: tc.id,
-              name: tc.name,
-              result: r.result,
-              isError: r.isError,
-              ...r.recording ? { recording: r.recording } : {}
+              result,
+              isError,
+              ...recording ? { recording } : {}
             });
-            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();
-            if (r.recording) {
-              block.recording = r.recording;
-            }
-            const innerMsgs = subAgentMessages.get(r.id);
-            if (innerMsgs) {
-              attachSubAgentTranscript(block, innerMsgs);
+          });
+          let toolAbort = new AbortController();
+          const cascadeAbort = () => toolAbort.abort();
+          signal?.addEventListener("abort", cascadeAbort, { once: true });
+          let settled = false;
+          const safeSettle = (result, isError, recording) => {
+            if (settled) {
+              return;
             }
-            if (captureArtifacts?.includes(block.name) && !r.isError) {
-              try {
-                artifacts[block.name] = JSON.parse(r.result);
-              } catch {
+            settled = true;
+            signal?.removeEventListener("abort", cascadeAbort);
+            settle(result, isError, recording);
+          };
+          const run2 = async (input) => {
+            try {
+              let result;
+              let recording;
+              if (externalTools.has(tc.name) && resolveExternalTool) {
+                result = await resolveExternalTool(tc.id, tc.name, input);
+                if (tc.name === "browserCommand") {
+                  const lifted = liftRecording(result);
+                  result = lifted.result;
+                  recording = lifted.recording;
+                }
+              } 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"),
+                recording
+              );
+            } catch (err) {
+              safeSettle(`Error: ${err.message}`, true);
             }
-          }
-          messages.push({
-            role: "user",
-            content: r.result,
-            toolCallId: r.id,
-            isToolError: r.isError
+          };
+          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);
+          log8.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,
+            ...r.recording ? { recording: r.recording } : {}
           });
+          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();
+          if (r.recording) {
+            block.recording = r.recording;
+          }
+          const innerMsgs = subAgentMessages.get(r.id);
+          if (innerMsgs) {
+            attachSubAgentTranscript(block, 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
+        });
       }
-    } finally {
-      statusWatcher.stop();
     }
   };
   const wrapRun = async () => {
@@ -5578,7 +5420,6 @@ var init_runner = __esm({
     init_toolRegistry();
     init_historyLimits();
     init_recording();
-    init_statusWatcher();
     init_cleanMessages();
     log8 = createLogger("sub-agent");
   }
@@ -9393,6 +9234,153 @@ var init_parsePartialJson = __esm({
   }
 });
 
+// src/statusWatcher.ts
+import { createHash } from "crypto";
+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;
+  let labeledContextHash = null;
+  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();
+      if (!context) {
+        return;
+      }
+      const contextHash = createHash("sha1").update(context).digest("hex");
+      const unchanged = contextHash === labeledContextHash;
+      const startedAt = Date.now();
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiConfig.apiKey}`,
+          // Also a liveness signal for this box, and the most frequent one there is — this ticks
+          // every few seconds for as long as the agent is working, which is exactly the window in
+          // which the user may have backgrounded the tab and stopped its own keepalive.
+          ...sandboxSessionHeader()
+        },
+        body: JSON.stringify({
+          appId: apiConfig.appId,
+          ...unchanged ? {} : { context }
+        }),
+        signal
+      });
+      if (stopped) {
+        return;
+      }
+      if (unchanged) {
+        await res.body?.cancel().catch(() => {
+        });
+        return;
+      }
+      if (!res.ok) {
+        recordFailure();
+        return;
+      }
+      const data = await res.json();
+      if (!data.label) {
+        recordFailure();
+        return;
+      }
+      recordUsage({
+        ts: Date.now(),
+        agentName: "statusLabel",
+        modelId: data.modelId,
+        inputTokens: data.usage?.inputTokens ?? 0,
+        outputTokens: data.usage?.outputTokens ?? 0,
+        cost: nanoToDollars(data.cost),
+        billingEvents: data.billingEvents,
+        durationMs: Date.now() - startedAt,
+        toolNames: []
+      });
+      consecutiveFailures = 0;
+      backoffMs = 0;
+      nextAllowedAt = 0;
+      if (pauseCount > 0 || stopped || signal?.aborted) {
+        return;
+      }
+      onStatus(data.label);
+      labeledContextHash = contextHash;
+    } catch {
+      if (!stopped && !signal?.aborted) {
+        recordFailure();
+      }
+    } finally {
+      inflight2 = false;
+    }
+  }
+  const timer = setInterval(tick, interval);
+  tick().catch(() => {
+  });
+  return {
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+    },
+    pause() {
+      pauseCount++;
+    },
+    resume() {
+      pauseCount = Math.max(0, pauseCount - 1);
+    }
+  };
+}
+var INTERNAL_PAYLOAD_MARKERS;
+var init_statusWatcher = __esm({
+  "src/statusWatcher.ts"() {
+    "use strict";
+    init_api();
+    init_usageLedger();
+    INTERNAL_PAYLOAD_MARKERS = [
+      "[USER CANCELLED]",
+      "[INTERRUPTED]",
+      "[INTERRUPTED - PARTIAL OUTPUT RETRIEVED]",
+      "<background_results>",
+      "<workspace_status>",
+      "<tool_result"
+    ];
+  }
+});
+
 // src/automatedActions/resolve.ts
 function resolveAction(text) {
   const parsed = parseSentinel(text);
@@ -9681,7 +9669,7 @@ var init_suggestions = __esm({
 // src/brandExtraction/index.ts
 import fs20 from "fs";
 import path11 from "path";
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 async function runExtraction(apiConfig, model) {
   const inputHash = computeInputHash();
   const cached3 = readCache();
@@ -9722,7 +9710,7 @@ function computeInputHash() {
   return sha256(fingerprint);
 }
 function sha256(input) {
-  return createHash("sha256").update(input).digest("hex");
+  return createHash2("sha256").update(input).digest("hex");
 }
 function readSafe(filePath) {
   try {