@mindstudio-ai/remy 0.1.164 → 0.1.165

package/dist/headless.d.ts

@@ -74,6 +74,20 @@ declare class HeadlessSession {
     private persistStats;
     /** Apply queued tool block updates to state.messages. Safe to call any time. */
     private applyPendingBlockUpdates;
+    /**
+     * Forced compaction gate. If lastContextSize exceeds the threshold, compact
+     * before letting the upcoming turn run. Coalesces with any in-flight
+     * compaction (e.g., one already started by /compact or a tool call). No
+     * timeout — compaction takes as long as it takes.
+     *
+     * Lifecycle events (`compaction_started` / `compaction_complete`) and
+     * stats updates are handled by the listener registered in start(); this
+     * method only awaits the promise and applies the resulting summaries.
+     *
+     * On compaction failure we don't bail — the turn proceeds and surfaces any
+     * downstream overflow through the existing "prompt is too long" path.
+     */
+    private runForcedCompactionIfNeeded;
     /** Drain pending compaction summaries and insert at a safe point. */
     private applyPendingSummaries;
     private onBackgroundComplete;

package/dist/headless.js

@@ -1757,8 +1757,10 @@ var compactConversationTool = {
     }
     triggerCompaction(
       { messages: context.conversationMessages },
-      context.apiConfig
-    );
+      context.apiConfig,
+      { blocking: false, requestId: context.requestId }
+    ).catch(() => {
+    });
     return "Compaction started in the background.";
   }
 };
@@ -5184,23 +5186,40 @@ function executeTool(name, input, context) {
 // src/compaction/trigger.ts
 var log7 = createLogger("compaction:trigger");
 var pendingSummaries = [];
+var inflightCompaction = null;
 function getPendingSummaries() {
   return pendingSummaries.splice(0);
 }
-function triggerCompaction(state, apiConfig, callbacks) {
-  callbacks?.onStart?.();
+var listener = null;
+function setCompactionListener(l) {
+  listener = l;
+}
+function triggerCompaction(state, apiConfig, opts = {}) {
+  if (inflightCompaction) {
+    return inflightCompaction;
+  }
+  const { blocking = false, requestId } = opts;
+  listener?.({ type: "started", blocking, requestId });
   const system = buildSystemPrompt("onboardingFinished");
   const tools2 = getToolDefinitions("onboardingFinished");
-  compactConversation(state.messages, apiConfig, system, tools2).then((summaries) => {
+  inflightCompaction = compactConversation(
+    state.messages,
+    apiConfig,
+    system,
+    tools2
+  ).then((summaries) => {
     pendingSummaries.push(...summaries);
-    callbacks?.onSummariesReady?.();
+    listener?.({ type: "complete", requestId });
     log7.info("Compaction complete");
   }).catch((err) => {
-    callbacks?.onError?.(err.message || "Compaction failed");
-    log7.error("Compaction failed", { error: err.message });
+    const message = err.message || "Compaction failed";
+    listener?.({ type: "complete", error: message, requestId });
+    log7.error("Compaction failed", { error: message });
+    throw err;
   }).finally(() => {
-    callbacks?.onFinally?.();
+    inflightCompaction = null;
   });
+  return inflightCompaction;
 }
 
 // src/brandExtraction/index.ts
@@ -6628,6 +6647,7 @@ var USER_FACING_TOOLS = /* @__PURE__ */ new Set([
   "confirmDestructiveAction",
   "presentPublishPlan"
 ]);
+var FORCED_COMPACTION_THRESHOLD_TOKENS = 85e4;
 var HeadlessSession = class {
   // Configuration
   opts;
@@ -6695,6 +6715,24 @@ var HeadlessSession = class {
     }
     triggerBrandExtraction(this.config);
     this.toolRegistry.onEvent = this.onEvent;
+    setCompactionListener((event) => {
+      if (event.type === "started") {
+        this.emit(
+          "compaction_started",
+          { blocking: event.blocking },
+          event.requestId
+        );
+        this.sessionStats.compactionInProgress = true;
+        this.persistStats();
+      } else {
+        const data = event.error ? { error: event.error } : {};
+        this.emit("compaction_complete", data, event.requestId);
+        this.sessionStats.compactionInProgress = false;
+        this.sessionStats.lastContextSize = 0;
+        this.sessionStats.messageCount = this.state.messages.length;
+        this.persistStats();
+      }
+    });
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       this.stdinBuffer += chunk;
@@ -6796,6 +6834,37 @@ var HeadlessSession = class {
     }
     saveSession(this.state);
   }
+  /**
+   * Forced compaction gate. If lastContextSize exceeds the threshold, compact
+   * before letting the upcoming turn run. Coalesces with any in-flight
+   * compaction (e.g., one already started by /compact or a tool call). No
+   * timeout — compaction takes as long as it takes.
+   *
+   * Lifecycle events (`compaction_started` / `compaction_complete`) and
+   * stats updates are handled by the listener registered in start(); this
+   * method only awaits the promise and applies the resulting summaries.
+   *
+   * On compaction failure we don't bail — the turn proceeds and surfaces any
+   * downstream overflow through the existing "prompt is too long" path.
+   */
+  async runForcedCompactionIfNeeded(requestId) {
+    if (this.sessionStats.lastContextSize <= FORCED_COMPACTION_THRESHOLD_TOKENS) {
+      return;
+    }
+    log14.info("Forced compaction gate triggered", {
+      contextSize: this.sessionStats.lastContextSize,
+      threshold: FORCED_COMPACTION_THRESHOLD_TOKENS,
+      requestId
+    });
+    try {
+      await triggerCompaction(this.state, this.config, {
+        blocking: true,
+        requestId
+      });
+      this.applyPendingSummaries();
+    } catch {
+    }
+  }
   /** Drain pending compaction summaries and insert at a safe point. */
   applyPendingSummaries() {
     const summaries = getPendingSummaries();
@@ -7027,6 +7096,7 @@ var HeadlessSession = class {
     this.currentAbort = new AbortController();
     this.completedEmitted = false;
     this.turnStart = Date.now();
+    await this.runForcedCompactionIfNeeded(requestId);
     const attachments = parsed.attachments;
     if (attachments?.length) {
       log14.info("Message has attachments", {
@@ -7333,29 +7403,19 @@ var HeadlessSession = class {
       return;
     }
     if (action === "compact") {
-      triggerCompaction(this.state, this.config, {
-        onStart: () => {
-          this.sessionStats.compactionInProgress = true;
-          this.persistStats();
-        },
-        onSummariesReady: () => {
-          if (!this.running) {
-            this.applyPendingSummaries();
-          }
-          this.emit("compaction_complete", {}, requestId);
-          this.emit("completed", { success: true }, requestId);
-        },
-        onError: (error) => {
-          this.emit("compaction_complete", { error }, requestId);
-          this.emit("completed", { success: false, error }, requestId);
-        },
-        onFinally: () => {
-          this.sessionStats.compactionInProgress = false;
-          this.sessionStats.lastContextSize = 0;
-          this.sessionStats.messageCount = this.state.messages.length;
-          this.persistStats();
+      try {
+        await triggerCompaction(this.state, this.config, {
+          blocking: false,
+          requestId
+        });
+        if (!this.running) {
+          this.applyPendingSummaries();
         }
-      });
+        this.emit("completed", { success: true }, requestId);
+      } catch (err) {
+        const error = err.message || "Compaction failed";
+        this.emit("completed", { success: false, error }, requestId);
+      }
       return;
     }
     if (action === "message") {

package/dist/index.js

@@ -1870,22 +1870,37 @@ var init_prompt = __esm({
 function getPendingSummaries() {
   return pendingSummaries.splice(0);
 }
-function triggerCompaction(state, apiConfig, callbacks) {
-  callbacks?.onStart?.();
+function setCompactionListener(l) {
+  listener = l;
+}
+function triggerCompaction(state, apiConfig, opts = {}) {
+  if (inflightCompaction) {
+    return inflightCompaction;
+  }
+  const { blocking = false, requestId } = opts;
+  listener?.({ type: "started", blocking, requestId });
   const system = buildSystemPrompt("onboardingFinished");
   const tools2 = getToolDefinitions("onboardingFinished");
-  compactConversation(state.messages, apiConfig, system, tools2).then((summaries) => {
+  inflightCompaction = compactConversation(
+    state.messages,
+    apiConfig,
+    system,
+    tools2
+  ).then((summaries) => {
     pendingSummaries.push(...summaries);
-    callbacks?.onSummariesReady?.();
+    listener?.({ type: "complete", requestId });
     log3.info("Compaction complete");
   }).catch((err) => {
-    callbacks?.onError?.(err.message || "Compaction failed");
-    log3.error("Compaction failed", { error: err.message });
+    const message = err.message || "Compaction failed";
+    listener?.({ type: "complete", error: message, requestId });
+    log3.error("Compaction failed", { error: message });
+    throw err;
   }).finally(() => {
-    callbacks?.onFinally?.();
+    inflightCompaction = null;
   });
+  return inflightCompaction;
 }
-var log3, pendingSummaries;
+var log3, pendingSummaries, inflightCompaction, listener;
 var init_trigger = __esm({
   "src/compaction/trigger.ts"() {
     "use strict";
@@ -1895,6 +1910,8 @@ var init_trigger = __esm({
     init_logger();
     log3 = createLogger("compaction:trigger");
     pendingSummaries = [];
+    inflightCompaction = null;
+    listener = null;
   }
 });
 
@@ -1920,8 +1937,10 @@ var init_compactConversation = __esm({
         }
         triggerCompaction(
           { messages: context.conversationMessages },
-          context.apiConfig
-        );
+          context.apiConfig,
+          { blocking: false, requestId: context.requestId }
+        ).catch(() => {
+        });
         return "Compaction started in the background.";
       }
     };
@@ -7355,7 +7374,7 @@ var headless_exports = {};
 __export(headless_exports, {
   HeadlessSession: () => HeadlessSession
 });
-var log14, EXTERNAL_TOOL_TIMEOUT_MS, USER_FACING_TOOLS, HeadlessSession;
+var log14, EXTERNAL_TOOL_TIMEOUT_MS, USER_FACING_TOOLS, FORCED_COMPACTION_THRESHOLD_TOKENS, HeadlessSession;
 var init_headless = __esm({
   "src/headless/index.ts"() {
     "use strict";
@@ -7382,6 +7401,7 @@ var init_headless = __esm({
       "confirmDestructiveAction",
       "presentPublishPlan"
     ]);
+    FORCED_COMPACTION_THRESHOLD_TOKENS = 85e4;
     HeadlessSession = class {
       // Configuration
       opts;
@@ -7449,6 +7469,24 @@ var init_headless = __esm({
         }
         triggerBrandExtraction(this.config);
         this.toolRegistry.onEvent = this.onEvent;
+        setCompactionListener((event) => {
+          if (event.type === "started") {
+            this.emit(
+              "compaction_started",
+              { blocking: event.blocking },
+              event.requestId
+            );
+            this.sessionStats.compactionInProgress = true;
+            this.persistStats();
+          } else {
+            const data = event.error ? { error: event.error } : {};
+            this.emit("compaction_complete", data, event.requestId);
+            this.sessionStats.compactionInProgress = false;
+            this.sessionStats.lastContextSize = 0;
+            this.sessionStats.messageCount = this.state.messages.length;
+            this.persistStats();
+          }
+        });
         process.stdin.setEncoding("utf-8");
         process.stdin.on("data", (chunk) => {
           this.stdinBuffer += chunk;
@@ -7550,6 +7588,37 @@ var init_headless = __esm({
         }
         saveSession(this.state);
       }
+      /**
+       * Forced compaction gate. If lastContextSize exceeds the threshold, compact
+       * before letting the upcoming turn run. Coalesces with any in-flight
+       * compaction (e.g., one already started by /compact or a tool call). No
+       * timeout — compaction takes as long as it takes.
+       *
+       * Lifecycle events (`compaction_started` / `compaction_complete`) and
+       * stats updates are handled by the listener registered in start(); this
+       * method only awaits the promise and applies the resulting summaries.
+       *
+       * On compaction failure we don't bail — the turn proceeds and surfaces any
+       * downstream overflow through the existing "prompt is too long" path.
+       */
+      async runForcedCompactionIfNeeded(requestId) {
+        if (this.sessionStats.lastContextSize <= FORCED_COMPACTION_THRESHOLD_TOKENS) {
+          return;
+        }
+        log14.info("Forced compaction gate triggered", {
+          contextSize: this.sessionStats.lastContextSize,
+          threshold: FORCED_COMPACTION_THRESHOLD_TOKENS,
+          requestId
+        });
+        try {
+          await triggerCompaction(this.state, this.config, {
+            blocking: true,
+            requestId
+          });
+          this.applyPendingSummaries();
+        } catch {
+        }
+      }
       /** Drain pending compaction summaries and insert at a safe point. */
       applyPendingSummaries() {
         const summaries = getPendingSummaries();
@@ -7781,6 +7850,7 @@ var init_headless = __esm({
         this.currentAbort = new AbortController();
         this.completedEmitted = false;
         this.turnStart = Date.now();
+        await this.runForcedCompactionIfNeeded(requestId);
         const attachments = parsed.attachments;
         if (attachments?.length) {
           log14.info("Message has attachments", {
@@ -8087,29 +8157,19 @@ var init_headless = __esm({
           return;
         }
         if (action === "compact") {
-          triggerCompaction(this.state, this.config, {
-            onStart: () => {
-              this.sessionStats.compactionInProgress = true;
-              this.persistStats();
-            },
-            onSummariesReady: () => {
-              if (!this.running) {
-                this.applyPendingSummaries();
-              }
-              this.emit("compaction_complete", {}, requestId);
-              this.emit("completed", { success: true }, requestId);
-            },
-            onError: (error) => {
-              this.emit("compaction_complete", { error }, requestId);
-              this.emit("completed", { success: false, error }, requestId);
-            },
-            onFinally: () => {
-              this.sessionStats.compactionInProgress = false;
-              this.sessionStats.lastContextSize = 0;
-              this.sessionStats.messageCount = this.state.messages.length;
-              this.persistStats();
+          try {
+            await triggerCompaction(this.state, this.config, {
+              blocking: false,
+              requestId
+            });
+            if (!this.running) {
+              this.applyPendingSummaries();
             }
-          });
+            this.emit("completed", { success: true }, requestId);
+          } catch (err) {
+            const error = err.message || "Compaction failed";
+            this.emit("completed", { success: false, error }, requestId);
+          }
           return;
         }
         if (action === "message") {

package/dist/prompt/static/instructions.md

@@ -13,7 +13,7 @@
 - Work with what you already know. If you've read a file in this session, use what you learned rather than reading it again. If a subagent already researched something, use its findings. Every tool call costs time; prefer acting on information you have over re-gathering it.
 - When multiple tool calls are independent, make them all in a single turn. Reading three files, writing two methods, or running a scenario while taking a screenshot: batch them instead of doing one per turn.
 - After two failed attempts at the same approach, tell the user what's going wrong.
-- Never estimate how long something will take or how much it will cost. Just do it. If the user asks, you must politely refuse and let them know that due to the way AI models work, any answer would just be a guess. You can, however, help them understand the scope and scale of the work, or how long it might take/how much it might cost a traditional engineering or product team (e.g., weeks/months, $100k USD+ to a consulting shop, etc.) - but you can not estimate token usage or costs of work within the system.
+- Never estimate how long something will take or how much it will cost. Just do it. If the user asks, politely refuse — any number would be a guess. Never quote concrete time units for work you're about to do. You can describe scope qualitatively (small change, large refactor, etc.), but never estimate the time it will take you to do work.
 - Pushing to main branch will trigger a deploy. The user presses the publish button in the interface to request publishing.
 
 ### Build Notes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstudio-ai/remy",
-  "version": "0.1.164",
+  "version": "0.1.165",
   "description": "MindStudio coding agent",
   "repository": {
     "type": "git",