@mindstudio-ai/remy 0.1.328 → 0.1.330

package/dist/headless.js

@@ -100,6 +100,87 @@ function resolveConfig(flags) {
   return { apiKey, baseUrl: baseUrl2, appId };
 }
 
+// src/loopGuard.ts
+var PARAGRAPH_REPEAT_THRESHOLD = 6;
+var MIN_PARAGRAPH_CHARS = 80;
+var CHUNK_SIZE = 60;
+var CHUNK_WINDOW = 5e3;
+var CHUNK_REPEAT_THRESHOLD = 10;
+var LONE_HEADER = /^\*{1,3}[^*].*\*{1,3}$/;
+function normalizeParagraph(seg) {
+  const trimmed = seg.trim();
+  if (!trimmed || LONE_HEADER.test(trimmed)) {
+    return null;
+  }
+  const key = trimmed.toLowerCase().replace(/\s+/g, " ");
+  if (key.length < MIN_PARAGRAPH_CHARS) {
+    return null;
+  }
+  return key;
+}
+var RepetitionDetector = class {
+  // Paragraph detector: incomplete tail awaiting its closing blank line, plus
+  // occurrence counts of completed, normalized paragraphs.
+  paragraphBuffer = "";
+  paragraphCounts = /* @__PURE__ */ new Map();
+  // Rolling-chunk detector: the trailing window of raw fed text.
+  window = "";
+  fired = false;
+  /**
+   * Feed the next streamed text fragment. Returns a signal the first time a
+   * loop is recognized, then null forever after (the caller aborts on the
+   * first signal; further feeds are harmless no-ops).
+   */
+  feed(text) {
+    if (this.fired || !text) {
+      return null;
+    }
+    return this.feedParagraphs(text) ?? this.feedChunks(text);
+  }
+  feedParagraphs(text) {
+    this.paragraphBuffer += text;
+    const segments = this.paragraphBuffer.split(/\n\s*\n/);
+    this.paragraphBuffer = segments.pop() ?? "";
+    for (const seg of segments) {
+      const key = normalizeParagraph(seg);
+      if (!key) {
+        continue;
+      }
+      const count = (this.paragraphCounts.get(key) ?? 0) + 1;
+      this.paragraphCounts.set(key, count);
+      if (count >= PARAGRAPH_REPEAT_THRESHOLD) {
+        this.fired = true;
+        return {
+          kind: "paragraph",
+          repeats: count,
+          sample: seg.trim().slice(0, 160)
+        };
+      }
+    }
+    return null;
+  }
+  feedChunks(text) {
+    this.window = (this.window + text).slice(-CHUNK_WINDOW);
+    if (this.window.length < CHUNK_SIZE * CHUNK_REPEAT_THRESHOLD) {
+      return null;
+    }
+    const tail = this.window.slice(-CHUNK_SIZE);
+    if (!tail.trim()) {
+      return null;
+    }
+    const occurrences = this.window.split(tail).length - 1;
+    if (occurrences >= CHUNK_REPEAT_THRESHOLD) {
+      this.fired = true;
+      return {
+        kind: "chunk",
+        repeats: occurrences,
+        sample: tail.replace(/\s+/g, " ").trim().slice(0, 160)
+      };
+    }
+    return null;
+  }
+};
+
 // src/api.ts
 var log2 = createLogger("api");
 async function* streamChat(params) {
@@ -311,17 +392,51 @@ async function* streamChatWithRetry(params, options) {
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     const buffer = [];
     let retryableFailure = false;
-    for await (const event of streamChat(params)) {
-      if (event.type === "error") {
-        if (isRetryableError(event.error, event.code) && attempt < MAX_RETRIES - 1) {
-          options?.onRetry?.(attempt, event.error);
-          retryableFailure = true;
-          break;
+    const detector = options?.detectRepetition ? new RepetitionDetector() : null;
+    const streamAbort = new AbortController();
+    const onCallerAbort = () => streamAbort.abort();
+    if (params.signal) {
+      if (params.signal.aborted) {
+        streamAbort.abort();
+      } else {
+        params.signal.addEventListener("abort", onCallerAbort, { once: true });
+      }
+    }
+    try {
+      for await (const event of streamChat({
+        ...params,
+        signal: streamAbort.signal
+      })) {
+        if (event.type === "error") {
+          if (isRetryableError(event.error, event.code) && attempt < MAX_RETRIES - 1) {
+            options?.onRetry?.(attempt, event.error);
+            retryableFailure = true;
+            break;
+          }
+          yield event;
+          return;
         }
-        yield event;
-        return;
+        if (detector && (event.type === "text" || event.type === "thinking")) {
+          const loop = detector.feed(event.text);
+          if (loop) {
+            log2.warn("Repetition loop detected \u2014 aborting call", {
+              requestId: params.requestId,
+              kind: loop.kind,
+              repeats: loop.repeats
+            });
+            streamAbort.abort();
+            yield {
+              type: "error",
+              error: "Response stopped: the model was repeating its reasoning without making progress.",
+              code: "repetition_loop"
+            };
+            return;
+          }
+        }
+        buffer.push(event);
       }
-      buffer.push(event);
+    } finally {
+      params.signal?.removeEventListener("abort", onCallerAbort);
     }
     if (retryableFailure) {
       if (params.signal?.aborted) {
@@ -3031,6 +3146,13 @@ var queryDatabaseTool = {
 // src/usageLedger.ts
 import fs16 from "fs";
 var LEDGER_FILE = ".logs/usage.ndjson";
+function thinkingTokensFromBilling(billingEvents, outputTokens) {
+  if (!billingEvents?.length) {
+    return 0;
+  }
+  const billedResponseUnits = billingEvents.filter((e) => e.eventType.endsWith("-response")).reduce((sum, e) => sum + e.numUnits, 0);
+  return Math.max(0, billedResponseUnits - outputTokens);
+}
 var fd = null;
 function nanoToDollars(nano) {
   return typeof nano === "number" ? nano / 1e9 : void 0;
@@ -8961,6 +9083,13 @@ function getActionChain(startName) {
 }
 
 // src/errors.ts
+var OVERFLOW_PATTERN = /input token count.*exceeds|exceeds the maximum number of tokens|prompt is too long|context[_ ]length[_ ]exceeded|maximum context length|HTTP 413|payload too large|request entity too large/i;
+function isContextOverflowError(message, code) {
+  if (code === "context_overflow") {
+    return true;
+  }
+  return OVERFLOW_PATTERN.test(message);
+}
 var patterns = [
   [
     /Network error/i,
@@ -8980,6 +9109,14 @@ var patterns = [
     "The AI service is temporarily unavailable. Please try again."
   ],
   [/Stream stalled/i, "The connection was interrupted. Please try again."],
+  [
+    // A too-large-context failure that survived the automatic compact-and-retry
+    // (or came from an older server). Kept ahead of the generic fallback so a
+    // raw provider string (e.g. Gemini's INVALID_ARGUMENT JSON) never reaches
+    // the user.
+    OVERFLOW_PATTERN,
+    "This conversation outgrew the model's context window. Remy compacted it and tried again; if you keep seeing this, run /compact or start a new conversation."
+  ],
   [
     /content filter|Output blocked/i,
     "The AI model's content moderation filter blocked this response. These are usually false positives, we apologize for the interruption. Rephrasing your request typically fixes this."
@@ -9284,8 +9421,33 @@ async function runTurn(params) {
   let lastCallInputTokens = 0;
   let lastCallCacheCreation = 0;
   let lastCallCacheRead = 0;
-  let abnormalStopRecoveries = 0;
-  const MAX_ABNORMAL_STOP_RECOVERIES = 2;
+  let recoveries = 0;
+  const MAX_RECOVERIES = 2;
+  let midTurnCompactions = 0;
+  const MAX_MID_TURN_COMPACTIONS = 2;
+  let overflowRecovered = false;
+  const compactNow = async (reason) => {
+    log15.warn("Compacting mid-turn", {
+      requestId,
+      reason,
+      lastCallInputTokens
+    });
+    onEvent({ type: "status", message: "Compacting the conversation\u2026" });
+    try {
+      await triggerCompaction(state, apiConfig, {
+        blocking: true,
+        requestId,
+        model,
+        origin: "gate"
+      });
+      applyPendingSummaries(state);
+    } catch (err) {
+      log15.error("Mid-turn compaction failed", {
+        requestId,
+        error: err?.message ?? String(err)
+      });
+    }
+  };
   const statusWatcher = isFirstMessage ? { stop() {
   }, pause() {
   }, resume() {
@@ -9432,6 +9594,7 @@ async function runTurn(params) {
           onEvent({ type: "tool_input_delta", id, name, result: content });
         }
       }
+      let streamError = null;
       try {
         for await (const event of streamChatWithRetry(
           {
@@ -9450,9 +9613,13 @@ async function runTurn(params) {
             onRetry: (attempt) => {
               onEvent({
                 type: "status",
-                message: `Lost connection, retrying (attempt ${attempt + 2} of 3)`
+                message: `Lost connection, retrying (attempt ${attempt + 2} of ${MAX_RETRIES})`
               });
-            }
+            },
+            // Watch the streamed reasoning/text for a runaway repetition loop
+            // and abort the in-flight call early (RPT-1225). Surfaces as a
+            // `repetition_loop` error handled below.
+            detectRepetition: true
           }
         )) {
           if (signal?.aborted) {
@@ -9476,7 +9643,7 @@ async function runTurn(params) {
               emitTextBlockSnapshot2(false);
               break;
             }
-            case "thinking":
+            case "thinking": {
               if (event.text === "") {
                 thinkingBlockStartTimes.push(event.ts);
                 if (textBlockOpen) {
@@ -9486,6 +9653,7 @@ async function runTurn(params) {
               }
               onEvent({ type: "thinking", text: event.text });
               break;
+            }
             case "thinking_complete": {
               const startedAt = thinkingBlockStartTimes[thinkingCompleteCount] ?? event.ts;
               contentBlocks.push({
@@ -9583,6 +9751,10 @@ async function runTurn(params) {
                 outputTokens: event.usage.outputTokens,
                 cacheCreationTokens: event.usage.cacheCreationTokens,
                 cacheReadTokens: event.usage.cacheReadTokens,
+                thinkingTokens: thinkingTokensFromBilling(
+                  event.billingEvents,
+                  event.usage.outputTokens
+                ) || void 0,
                 cost: nanoToDollars(event.cost),
                 billingEvents: event.billingEvents,
                 durationMs: Date.now() - iterStart,
@@ -9592,13 +9764,11 @@ async function runTurn(params) {
               });
               break;
             case "error":
-              statusWatcher.stop();
-              onEvent({
-                type: "error",
-                error: friendlyError(event.error),
-                ...event.code ? { code: event.code } : {}
-              });
-              return;
+              streamError = { error: event.error, code: event.code };
+              break;
+          }
+          if (streamError) {
+            break;
           }
         }
       } catch (err) {
@@ -9643,6 +9813,51 @@ async function runTurn(params) {
         saveSession(state);
         return;
       }
+      if (streamError) {
+        const { error, code } = streamError;
+        if (code === "repetition_loop") {
+          if (recoveries < MAX_RECOVERIES && !signal?.aborted) {
+            recoveries++;
+            log15.warn("Repetition loop \u2014 nudging model to continue", {
+              requestId,
+              attempt: recoveries
+            });
+            const nudge = "Your previous response was stopped because it kept repeating the same reasoning without making progress. Do not deliberate further \u2014 take the next concrete action now: make the tool call or give the answer.";
+            state.messages.push({
+              role: "user",
+              content: nudge,
+              hidden: true
+            });
+            onEvent({ type: "user_message", text: nudge, hidden: true });
+            continue;
+          }
+          statusWatcher.stop();
+          saveSession(state);
+          log15.warn("Repetition loop over recovery cap \u2014 ending turn", {
+            requestId
+          });
+          onEvent({
+            type: "error",
+            error: "The model kept repeating itself without making progress, so Remy stopped the turn to avoid runaway cost. Try again, or rephrase your request.",
+            lastCallInputTokens
+          });
+          return;
+        }
+        if (isContextOverflowError(error, code) && !overflowRecovered && !signal?.aborted) {
+          overflowRecovered = true;
+          await compactNow("context overflow");
+          continue;
+        }
+        statusWatcher.stop();
+        saveSession(state);
+        onEvent({
+          type: "error",
+          error: friendlyError(error),
+          ...code ? { code } : {},
+          lastCallInputTokens
+        });
+        return;
+      }
       if (contentBlocks.length > 0) {
         state.messages.push({
           role: "assistant",
@@ -9662,14 +9877,14 @@ async function runTurn(params) {
         });
       }
       const toolCalls = getToolCalls(contentBlocks);
-      if (toolCalls.length === 0 && (stopReason === "repetition" || stopReason === "max_tokens") && abnormalStopRecoveries < MAX_ABNORMAL_STOP_RECOVERIES && !signal?.aborted) {
-        abnormalStopRecoveries++;
+      if (toolCalls.length === 0 && (stopReason === "repetition" || stopReason === "max_tokens") && recoveries < MAX_RECOVERIES && !signal?.aborted) {
+        recoveries++;
         log15.warn("Abnormal stop \u2014 nudging model to continue", {
           requestId,
           stopReason,
-          attempt: abnormalStopRecoveries
+          attempt: recoveries
         });
-        const nudge = "Your previous response was cut off \u2014 it degenerated into repeated text or hit the output limit, and the repeated portion was removed. Reassess where you are in the task and continue from where you left off. Prefer a tool call over restating what you were about to do.";
+        const nudge = "Your previous response was cut off before you finished \u2014 it hit the output limit (often from over-long reasoning) or degenerated into repeated text, and the unusable part was removed. Stop deliberating, reassess where you are, and continue with a concrete tool call rather than restating your plan.";
         state.messages.push({ role: "user", content: nudge, hidden: true });
         onEvent({ type: "user_message", text: nudge, hidden: true });
         continue;
@@ -9862,6 +10077,11 @@ async function runTurn(params) {
           isToolError: r.isError
         });
       }
+      const { forceCompactAt } = getContextLimits(parentModel);
+      if (lastCallInputTokens > forceCompactAt && midTurnCompactions < MAX_MID_TURN_COMPACTIONS && !signal?.aborted) {
+        midTurnCompactions++;
+        await compactNow(`context ${lastCallInputTokens} > ${forceCompactAt}`);
+      }
       if (takeSteering && !signal?.aborted) {
         const injected = (await takeSteering()).filter(
           (e) => e.text.trim().length > 0 || (e.attachments?.length ?? 0) > 0
@@ -10911,6 +11131,10 @@ var HeadlessSession = class {
         );
         return;
       case "error":
+        if (typeof e.lastCallInputTokens === "number") {
+          this.sessionStats.lastContextSize = e.lastCallInputTokens;
+          this.persistStats();
+        }
         this.emit(
           "error",
           { error: e.error, ...e.code ? { code: e.code } : {} },

package/dist/index.js

@@ -84,6 +84,93 @@ var init_logger = __esm({
   }
 });
 
+// src/loopGuard.ts
+function normalizeParagraph(seg) {
+  const trimmed = seg.trim();
+  if (!trimmed || LONE_HEADER.test(trimmed)) {
+    return null;
+  }
+  const key = trimmed.toLowerCase().replace(/\s+/g, " ");
+  if (key.length < MIN_PARAGRAPH_CHARS) {
+    return null;
+  }
+  return key;
+}
+var PARAGRAPH_REPEAT_THRESHOLD, MIN_PARAGRAPH_CHARS, CHUNK_SIZE, CHUNK_WINDOW, CHUNK_REPEAT_THRESHOLD, LONE_HEADER, RepetitionDetector;
+var init_loopGuard = __esm({
+  "src/loopGuard.ts"() {
+    "use strict";
+    PARAGRAPH_REPEAT_THRESHOLD = 6;
+    MIN_PARAGRAPH_CHARS = 80;
+    CHUNK_SIZE = 60;
+    CHUNK_WINDOW = 5e3;
+    CHUNK_REPEAT_THRESHOLD = 10;
+    LONE_HEADER = /^\*{1,3}[^*].*\*{1,3}$/;
+    RepetitionDetector = class {
+      // Paragraph detector: incomplete tail awaiting its closing blank line, plus
+      // occurrence counts of completed, normalized paragraphs.
+      paragraphBuffer = "";
+      paragraphCounts = /* @__PURE__ */ new Map();
+      // Rolling-chunk detector: the trailing window of raw fed text.
+      window = "";
+      fired = false;
+      /**
+       * Feed the next streamed text fragment. Returns a signal the first time a
+       * loop is recognized, then null forever after (the caller aborts on the
+       * first signal; further feeds are harmless no-ops).
+       */
+      feed(text) {
+        if (this.fired || !text) {
+          return null;
+        }
+        return this.feedParagraphs(text) ?? this.feedChunks(text);
+      }
+      feedParagraphs(text) {
+        this.paragraphBuffer += text;
+        const segments = this.paragraphBuffer.split(/\n\s*\n/);
+        this.paragraphBuffer = segments.pop() ?? "";
+        for (const seg of segments) {
+          const key = normalizeParagraph(seg);
+          if (!key) {
+            continue;
+          }
+          const count = (this.paragraphCounts.get(key) ?? 0) + 1;
+          this.paragraphCounts.set(key, count);
+          if (count >= PARAGRAPH_REPEAT_THRESHOLD) {
+            this.fired = true;
+            return {
+              kind: "paragraph",
+              repeats: count,
+              sample: seg.trim().slice(0, 160)
+            };
+          }
+        }
+        return null;
+      }
+      feedChunks(text) {
+        this.window = (this.window + text).slice(-CHUNK_WINDOW);
+        if (this.window.length < CHUNK_SIZE * CHUNK_REPEAT_THRESHOLD) {
+          return null;
+        }
+        const tail = this.window.slice(-CHUNK_SIZE);
+        if (!tail.trim()) {
+          return null;
+        }
+        const occurrences = this.window.split(tail).length - 1;
+        if (occurrences >= CHUNK_REPEAT_THRESHOLD) {
+          this.fired = true;
+          return {
+            kind: "chunk",
+            repeats: occurrences,
+            sample: tail.replace(/\s+/g, " ").trim().slice(0, 160)
+          };
+        }
+        return null;
+      }
+    };
+  }
+});
+
 // src/api.ts
 async function* streamChat(params) {
   const { baseUrl: baseUrl2, apiKey, signal, requestId, model, ...rest } = params;
@@ -286,17 +373,51 @@ async function* streamChatWithRetry(params, options) {
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     const buffer = [];
     let retryableFailure = false;
-    for await (const event of streamChat(params)) {
-      if (event.type === "error") {
-        if (isRetryableError(event.error, event.code) && attempt < MAX_RETRIES - 1) {
-          options?.onRetry?.(attempt, event.error);
-          retryableFailure = true;
-          break;
+    const detector = options?.detectRepetition ? new RepetitionDetector() : null;
+    const streamAbort = new AbortController();
+    const onCallerAbort = () => streamAbort.abort();
+    if (params.signal) {
+      if (params.signal.aborted) {
+        streamAbort.abort();
+      } else {
+        params.signal.addEventListener("abort", onCallerAbort, { once: true });
+      }
+    }
+    try {
+      for await (const event of streamChat({
+        ...params,
+        signal: streamAbort.signal
+      })) {
+        if (event.type === "error") {
+          if (isRetryableError(event.error, event.code) && attempt < MAX_RETRIES - 1) {
+            options?.onRetry?.(attempt, event.error);
+            retryableFailure = true;
+            break;
+          }
+          yield event;
+          return;
         }
-        yield event;
-        return;
+        if (detector && (event.type === "text" || event.type === "thinking")) {
+          const loop = detector.feed(event.text);
+          if (loop) {
+            log.warn("Repetition loop detected \u2014 aborting call", {
+              requestId: params.requestId,
+              kind: loop.kind,
+              repeats: loop.repeats
+            });
+            streamAbort.abort();
+            yield {
+              type: "error",
+              error: "Response stopped: the model was repeating its reasoning without making progress.",
+              code: "repetition_loop"
+            };
+            return;
+          }
+        }
+        buffer.push(event);
       }
-      buffer.push(event);
+    } finally {
+      params.signal?.removeEventListener("abort", onCallerAbort);
     }
     if (retryableFailure) {
       if (params.signal?.aborted) {
@@ -375,6 +496,7 @@ var init_api = __esm({
   "src/api.ts"() {
     "use strict";
     init_logger();
+    init_loopGuard();
     log = createLogger("api");
     MAX_RETRIES = 5;
     INITIAL_BACKOFF_MS = 1e3;
@@ -1543,6 +1665,13 @@ var init_sentinel = __esm({
 
 // src/usageLedger.ts
 import fs9 from "fs";
+function thinkingTokensFromBilling(billingEvents, outputTokens) {
+  if (!billingEvents?.length) {
+    return 0;
+  }
+  const billedResponseUnits = billingEvents.filter((e) => e.eventType.endsWith("-response")).reduce((sum, e) => sum + e.numUnits, 0);
+  return Math.max(0, billedResponseUnits - outputTokens);
+}
 function nanoToDollars(nano) {
   return typeof nano === "number" ? nano / 1e9 : void 0;
 }
@@ -9311,6 +9440,12 @@ var init_resolve = __esm({
 });
 
 // src/errors.ts
+function isContextOverflowError(message, code) {
+  if (code === "context_overflow") {
+    return true;
+  }
+  return OVERFLOW_PATTERN.test(message);
+}
 function friendlyError(raw) {
   for (const [pattern, message] of patterns) {
     if (pattern.test(raw)) {
@@ -9319,10 +9454,11 @@ function friendlyError(raw) {
   }
   return `Something went wrong: ${raw}`;
 }
-var patterns;
+var OVERFLOW_PATTERN, patterns;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
+    OVERFLOW_PATTERN = /input token count.*exceeds|exceeds the maximum number of tokens|prompt is too long|context[_ ]length[_ ]exceeded|maximum context length|HTTP 413|payload too large|request entity too large/i;
     patterns = [
       [
         /Network error/i,
@@ -9342,6 +9478,14 @@ var init_errors = __esm({
         "The AI service is temporarily unavailable. Please try again."
       ],
       [/Stream stalled/i, "The connection was interrupted. Please try again."],
+      [
+        // A too-large-context failure that survived the automatic compact-and-retry
+        // (or came from an older server). Kept ahead of the generic fallback so a
+        // raw provider string (e.g. Gemini's INVALID_ARGUMENT JSON) never reaches
+        // the user.
+        OVERFLOW_PATTERN,
+        "This conversation outgrew the model's context window. Remy compacted it and tried again; if you keep seeing this, run /compact or start a new conversation."
+      ],
       [
         /content filter|Output blocked/i,
         "The AI model's content moderation filter blocked this response. These are usually false positives, we apologize for the interruption. Rephrasing your request typically fixes this."
@@ -9987,8 +10131,33 @@ async function runTurn(params) {
   let lastCallInputTokens = 0;
   let lastCallCacheCreation = 0;
   let lastCallCacheRead = 0;
-  let abnormalStopRecoveries = 0;
-  const MAX_ABNORMAL_STOP_RECOVERIES = 2;
+  let recoveries = 0;
+  const MAX_RECOVERIES = 2;
+  let midTurnCompactions = 0;
+  const MAX_MID_TURN_COMPACTIONS = 2;
+  let overflowRecovered = false;
+  const compactNow = async (reason) => {
+    log14.warn("Compacting mid-turn", {
+      requestId,
+      reason,
+      lastCallInputTokens
+    });
+    onEvent({ type: "status", message: "Compacting the conversation\u2026" });
+    try {
+      await triggerCompaction(state, apiConfig, {
+        blocking: true,
+        requestId,
+        model,
+        origin: "gate"
+      });
+      applyPendingSummaries(state);
+    } catch (err) {
+      log14.error("Mid-turn compaction failed", {
+        requestId,
+        error: err?.message ?? String(err)
+      });
+    }
+  };
   const statusWatcher = isFirstMessage ? { stop() {
   }, pause() {
   }, resume() {
@@ -10135,6 +10304,7 @@ async function runTurn(params) {
           onEvent({ type: "tool_input_delta", id, name, result: content });
         }
       }
+      let streamError = null;
       try {
         for await (const event of streamChatWithRetry(
           {
@@ -10153,9 +10323,13 @@ async function runTurn(params) {
             onRetry: (attempt) => {
               onEvent({
                 type: "status",
-                message: `Lost connection, retrying (attempt ${attempt + 2} of 3)`
+                message: `Lost connection, retrying (attempt ${attempt + 2} of ${MAX_RETRIES})`
               });
-            }
+            },
+            // Watch the streamed reasoning/text for a runaway repetition loop
+            // and abort the in-flight call early (RPT-1225). Surfaces as a
+            // `repetition_loop` error handled below.
+            detectRepetition: true
           }
         )) {
           if (signal?.aborted) {
@@ -10179,7 +10353,7 @@ async function runTurn(params) {
               emitTextBlockSnapshot2(false);
               break;
             }
-            case "thinking":
+            case "thinking": {
               if (event.text === "") {
                 thinkingBlockStartTimes.push(event.ts);
                 if (textBlockOpen) {
@@ -10189,6 +10363,7 @@ async function runTurn(params) {
               }
               onEvent({ type: "thinking", text: event.text });
               break;
+            }
             case "thinking_complete": {
               const startedAt = thinkingBlockStartTimes[thinkingCompleteCount] ?? event.ts;
               contentBlocks.push({
@@ -10286,6 +10461,10 @@ async function runTurn(params) {
                 outputTokens: event.usage.outputTokens,
                 cacheCreationTokens: event.usage.cacheCreationTokens,
                 cacheReadTokens: event.usage.cacheReadTokens,
+                thinkingTokens: thinkingTokensFromBilling(
+                  event.billingEvents,
+                  event.usage.outputTokens
+                ) || void 0,
                 cost: nanoToDollars(event.cost),
                 billingEvents: event.billingEvents,
                 durationMs: Date.now() - iterStart,
@@ -10295,13 +10474,11 @@ async function runTurn(params) {
               });
               break;
             case "error":
-              statusWatcher.stop();
-              onEvent({
-                type: "error",
-                error: friendlyError(event.error),
-                ...event.code ? { code: event.code } : {}
-              });
-              return;
+              streamError = { error: event.error, code: event.code };
+              break;
+          }
+          if (streamError) {
+            break;
           }
         }
       } catch (err) {
@@ -10346,6 +10523,51 @@ async function runTurn(params) {
         saveSession(state);
         return;
       }
+      if (streamError) {
+        const { error, code } = streamError;
+        if (code === "repetition_loop") {
+          if (recoveries < MAX_RECOVERIES && !signal?.aborted) {
+            recoveries++;
+            log14.warn("Repetition loop \u2014 nudging model to continue", {
+              requestId,
+              attempt: recoveries
+            });
+            const nudge = "Your previous response was stopped because it kept repeating the same reasoning without making progress. Do not deliberate further \u2014 take the next concrete action now: make the tool call or give the answer.";
+            state.messages.push({
+              role: "user",
+              content: nudge,
+              hidden: true
+            });
+            onEvent({ type: "user_message", text: nudge, hidden: true });
+            continue;
+          }
+          statusWatcher.stop();
+          saveSession(state);
+          log14.warn("Repetition loop over recovery cap \u2014 ending turn", {
+            requestId
+          });
+          onEvent({
+            type: "error",
+            error: "The model kept repeating itself without making progress, so Remy stopped the turn to avoid runaway cost. Try again, or rephrase your request.",
+            lastCallInputTokens
+          });
+          return;
+        }
+        if (isContextOverflowError(error, code) && !overflowRecovered && !signal?.aborted) {
+          overflowRecovered = true;
+          await compactNow("context overflow");
+          continue;
+        }
+        statusWatcher.stop();
+        saveSession(state);
+        onEvent({
+          type: "error",
+          error: friendlyError(error),
+          ...code ? { code } : {},
+          lastCallInputTokens
+        });
+        return;
+      }
       if (contentBlocks.length > 0) {
         state.messages.push({
           role: "assistant",
@@ -10365,14 +10587,14 @@ async function runTurn(params) {
         });
       }
       const toolCalls = getToolCalls(contentBlocks);
-      if (toolCalls.length === 0 && (stopReason === "repetition" || stopReason === "max_tokens") && abnormalStopRecoveries < MAX_ABNORMAL_STOP_RECOVERIES && !signal?.aborted) {
-        abnormalStopRecoveries++;
+      if (toolCalls.length === 0 && (stopReason === "repetition" || stopReason === "max_tokens") && recoveries < MAX_RECOVERIES && !signal?.aborted) {
+        recoveries++;
         log14.warn("Abnormal stop \u2014 nudging model to continue", {
           requestId,
           stopReason,
-          attempt: abnormalStopRecoveries
+          attempt: recoveries
         });
-        const nudge = "Your previous response was cut off \u2014 it degenerated into repeated text or hit the output limit, and the repeated portion was removed. Reassess where you are in the task and continue from where you left off. Prefer a tool call over restating what you were about to do.";
+        const nudge = "Your previous response was cut off before you finished \u2014 it hit the output limit (often from over-long reasoning) or degenerated into repeated text, and the unusable part was removed. Stop deliberating, reassess where you are, and continue with a concrete tool call rather than restating your plan.";
         state.messages.push({ role: "user", content: nudge, hidden: true });
         onEvent({ type: "user_message", text: nudge, hidden: true });
         continue;
@@ -10565,6 +10787,11 @@ async function runTurn(params) {
           isToolError: r.isError
         });
       }
+      const { forceCompactAt } = getContextLimits(parentModel);
+      if (lastCallInputTokens > forceCompactAt && midTurnCompactions < MAX_MID_TURN_COMPACTIONS && !signal?.aborted) {
+        midTurnCompactions++;
+        await compactNow(`context ${lastCallInputTokens} > ${forceCompactAt}`);
+      }
       if (takeSteering && !signal?.aborted) {
         const injected = (await takeSteering()).filter(
           (e) => e.text.trim().length > 0 || (e.attachments?.length ?? 0) > 0
@@ -10606,6 +10833,7 @@ var init_agent = __esm({
     init_sentinel();
     init_trigger2();
     init_surfaces();
+    init_trigger();
     init_toolRegistry();
     init_historyLimits();
     log14 = createLogger("agent");
@@ -11958,6 +12186,10 @@ var init_headless = __esm({
             );
             return;
           case "error":
+            if (typeof e.lastCallInputTokens === "number") {
+              this.sessionStats.lastContextSize = e.lastCallInputTokens;
+              this.persistStats();
+            }
             this.emit(
               "error",
               { error: e.error, ...e.code ? { code: e.code } : {} },

package/dist/prompt/compiled/sdk-actions.md

@@ -42,7 +42,7 @@ result.$billingCost;         // cost in credits (if applicable)
 |--------|-------------|-----------|------------|
 | `analyzeImage` | Vision model analysis | `prompt`, `imageUrl` | `analysis` |
 | `analyzeVideo` | Video analysis | `prompt`, `videoUrl` | `analysis` |
-| `transcribeAudio` | Audio to text | `audioUrl` | `transcription` |
+| `transcribeAudio` | Audio to text | `audioUrl` | `text`, `segments` |
 | `extractText` | Extract text from documents/images | `url` | `text` |
 | `detectPII` | Find personal data | `text` | `entities` |
 

package/dist/prompt/skills/dataSources.md

@@ -40,6 +40,8 @@ Created on first use, so searching a source the build hasn't populated returns n
 
 **Filtering** narrows a search before ranking, and every condition only narrows: `filter: { metadata: { department: 'legal', year: [2025, 2026], signedAt: { gte: 20250101 } }, filename, documentIds, pages: { min?, max? }, contains: 'all these words', phrase: 'exact adjacent sequence' }`. Metadata matches per key: scalar = equals, array = any-of, `{ gte?, lte? }` = numeric range — ranges are numeric only, so store dates as sortable integers at add time (YYYYMMDD or epoch seconds) to range on them. Metadata is tagged at add time (scalars only, ≤16 keys); re-adding the same bytes with different metadata updates the tags in place, free. Filters are the right tool for scoping retrieval (per-user, per-category, a date window); they are NOT a substitute for a `db` query over structured data.
 
+**Counting matches.** `Policies.count(filter)` returns `{ chunks }`: how many passages match a filter, exactly, over the whole corpus, in the same grammar as `search`'s filter. `count({ contains: query })` is the honest number to show beside a search's hits: "8 of 3,891 passages mention these words". It is not a relevance count (none exists; similarity is a continuous score over every chunk) and it is not the set `search` returns (semantic hits need not contain the words, lexical hits may contain only some), so never label it "relevant results" or "matches for your query". Chunks, not documents. Counts share the 300/minute search limit; a count beside every search spends two. Same `index_warming` / `index_building` handling as search.
+
 **Modes**: `mode: 'hybrid'` (default) fuses semantic and keyword retrieval; `'semantic'` is the embedding alone; `'lexical'` is keyword-only with **no query embedding** — cheapest and fastest, right when the query is an identifier (an error code, a SKU, a name) rather than a meaning. `maxPerDocument: 2` stops one document monopolizing the results when the answer should draw on several. `highlight: true` adds `matches` (`{start, end}` offsets into `text`) for rendering highlighted excerpts.
 
 Search is deterministic for a fixed corpus and configuration, so eval sets and regression checks are meaningful — key them on `(documentId, chunkIndex)` rather than on chunk text.
@@ -206,6 +208,8 @@ remy-admin datasources remap --source archive --wait
 
 **A mapper is a pure transform: one object in, documents out, nothing else.** `remap` and `jobs replay` run it again over the raw copies, and a frame runs in the context of the release that compiled it, so anything a mapper writes on the side is written twice and possibly into the wrong data plane. The per-document facts an app needs later belong in `metadata`; an app that wants its own view of a big corpus (a timeline, counts by year, a table of ids) builds it after ingest by walking `Source.allDocuments()` in a background task, and keeps it current from what each sync adds.
 
+On a job, mapping is its own stage. The mapper turns each object into documents; the platform then ingests those documents in parallel batches of fifty across its workers, whatever one object became. So the size of an object does not set the pace, and a bundle of a thousand records is fine; only the number of objects sets how wide the mapping stage itself runs (three huge files map on three workers, the plan says so as a warning). `jobs status` reads "mapping N of M objects" until that stage is through, then counts documents.
+
 A mapper runs on the platform, so the platform has to build it. Any push builds it, and a branch push is a private preview build, which is all a mapper needs. `map deploy` then makes that build's mapper the source's active one: jobs, syncs and `add()` run it from then on, whether or not the app has ever been published. Publishing activates the mapper the live release declares — which is the one you deployed, since publishing fast-forwards the default branch to your branch. So there is nothing extra to do at publish time, and nothing to merge by hand: publishing is the merge (see the publishing skill). `jobs start` refuses with `mapper_not_deployed` while the dev session declares a mapper that is not yet active, because the job would otherwise load the raw records as documents.
 
 `map test --dev` needs the dev session running (`npx mindstudio dev`); it runs the mapper from local source through the tunnel and prints every outcome with markdown previews. The plan of a mapped job records the mapper's outcome mix on its sample; a run whose skip share climbs past twice that pauses with `pauseReason: 'skips'` for a look at the quarantine. `remap` reads the platform's own raw copies — no origin traffic — skips unchanged markdown by hash, and supersedes changed documents, so a metadata tweak on a million-document source costs frames and little else. `externalId` is the identity everything replaces by; choose it deliberately (the record's stable id, never the key of a file that gets rewritten in place).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstudio-ai/remy",
-  "version": "0.1.328",
+  "version": "0.1.330",
   "description": "Remy coding agent",
   "repository": {
     "type": "git",