@mindstudio-ai/remy 0.1.293 → 0.1.294

package/dist/headless.d.ts

@@ -173,8 +173,9 @@ declare class HeadlessSession {
      */
     private isDrainBarrier;
     /**
-     * Drain the queue in strict FIFO order. Caller must hold `running = true`.
-     * User messages arriving during the drain will be enqueued behind current items.
+     * Drain the queue in FIFO order over its deliverable items. Caller must hold
+     * `running = true`. User messages arriving during the drain will be enqueued
+     * behind current items.
      *
      * The queue serves two purposes with opposite delivery semantics:
      * - Sequencer: chain steps and sentinel-bearing user items are pipeline
@@ -184,6 +185,11 @@ declare class HeadlessSession {
      *   merged turn, so the model reconciles all of it at once instead of
      *   burning a full turn per item (and possibly executing instructions a
      *   later queued message already amended).
+     *
+     * Held items are not in the delivery sequence at all: the drain starts at the
+     * first deliverable item and never merges across a held one. It skips rather
+     * than stops because a held message sits at the head of the array — stopping
+     * there would strand the chain steps and background results behind it.
      */
     private drainQueueLoop;
     /**
@@ -205,17 +211,28 @@ declare class HeadlessSession {
      * every agent to "use server defaults". */
     private handleChangeModels;
     /**
-     * Cancel the running turn and flush the follow-ups that belonged to it
-     * (`chain`/`background`), while preserving `source: 'user'` items — those are
-     * independent user intent, not tied to the aborted run. The preserved user
-     * messages run next: `executeTurn` swallows the abort, so `handleMessage`
-     * falls through to `drainQueueLoop` with `running` still held. Returns the
-     * flushed items (for the cancel command's resume/discard UX).
+     * Stop everything the user can see running: the turn, an in-flight
+     * compaction, and any external tool waiting on a result. Flushes the
+     * follow-ups that belonged to the turn (`chain`/`background`) and HOLDS the
+     * `source: 'user'` items — those are independent user intent, so they're
+     * kept, but they no longer run on their own.
+     *
+     * Holding is the difference between Stop working and Stop looking broken.
+     * These items used to drain immediately: `executeTurn` swallows the abort,
+     * so `handleMessage` fell through to `drainQueueLoop` with `running` still
+     * held and the next turn began in the same tick — the spinner never stopped,
+     * and every additional press hit a turn that had just started. They now wait
+     * in the queue card until the user sends again or promotes one.
+     *
+     * A compaction is cancelled here too, unconditionally. It gates every queued
+     * message and outlives the turn that started it, so leaving it running means
+     * Stop can't reach idle. The cost is the summary work in flight; the forced
+     * gate re-compacts on the next turn if the context is still too big.
      *
-     * Messages already absorbed into the in-flight merged turn are NOT
-     * preserved — they were delivered into the turn that's being cancelled and
-     * each gets a `{cancelled, absorbed:true}` terminal. Only items still
-     * sitting in the queue survive.
+     * Messages already absorbed into the in-flight merged turn are NOT held —
+     * they were delivered into the turn that's being cancelled and each gets a
+     * `{cancelled, absorbed:true}` terminal. Only items still sitting in the
+     * queue survive.
      */
     private handleCancel;
     /**

package/dist/headless.js

@@ -212,12 +212,17 @@ async function* streamChat(params) {
       }
       const isStall = err?.message === "stream_stall";
       const errorMessage = isStall ? "Stream stalled \u2014 no data received for 5 minutes" : `Network error: stream interrupted \u2014 ${err?.message ?? "unknown"}`;
-      log2.error(isStall ? "Stream stalled" : "Stream interrupted", {
-        requestId,
-        ...subAgentId && { subAgentId },
-        durationMs: Date.now() - startTime,
-        error: errorMessage
-      });
+      const wasAborted = !isStall && !!signal?.aborted;
+      const logAt = wasAborted ? log2.warn : log2.error;
+      logAt(
+        wasAborted ? "Request aborted mid-stream" : isStall ? "Stream stalled" : "Stream interrupted",
+        {
+          requestId,
+          ...subAgentId && { subAgentId },
+          durationMs: Date.now() - startTime,
+          error: errorMessage
+        }
+      );
       yield { type: "error", error: errorMessage };
       return;
     }
@@ -2075,7 +2080,9 @@ var compactConversationTool = {
       onBackgroundComplete?.(
         toolCallId,
         "compactConversation",
-        `Error: ${err.message || "Compaction failed"}`
+        // A cancel is the user's own doing — report it as an outcome, not as
+        // an error the block renders as a failure.
+        err instanceof CompactionCancelledError ? err.message : `Error: ${err.message || "Compaction failed"}`
       );
     }).finally(() => {
       toolRegistry?.unregister(toolCallId);
@@ -6856,7 +6863,7 @@ var log10 = createLogger("compaction");
 var CONVERSATION_SUMMARY_PROMPT = readAsset("compaction", "conversation.md");
 var SUBAGENT_SUMMARY_PROMPT = readAsset("compaction", "subagent.md");
 var SUMMARIZABLE_SUBAGENTS = ["visualDesignExpert", "productVision"];
-async function compactConversation(messages, apiConfig, model) {
+async function compactConversation(messages, apiConfig, model, signal) {
   const endIndex = findSafeInsertionPoint(messages);
   const boundary = endIndex > 0 ? messages[endIndex - 1] : null;
   const summaries = [];
@@ -6873,7 +6880,8 @@ async function compactConversation(messages, apiConfig, model) {
         "conversation",
         CONVERSATION_SUMMARY_PROMPT,
         conversationMessages,
-        model
+        model,
+        { signal }
       ).then((text) => {
         if (text) {
           summaries.push({ name: "conversation", text });
@@ -6896,7 +6904,8 @@ async function compactConversation(messages, apiConfig, model) {
           name,
           SUBAGENT_SUMMARY_PROMPT,
           subagentMessages,
-          model
+          model,
+          { signal }
         ).then((text) => {
           if (text) {
             summaries.push({ name, text });
@@ -6912,7 +6921,7 @@ async function compactConversation(messages, apiConfig, model) {
   await Promise.all(tasks);
   if (conversationFailed) {
     throw new Error(
-      "Could not summarize the conversation \u2014 the model did not return a usable summary. History left intact."
+      signal?.aborted ? "Compaction cancelled. History left intact." : "Could not summarize the conversation \u2014 the model did not return a usable summary. History left intact."
     );
   }
   const recent = collectRecentNarrative(conversationMessages);
@@ -7152,7 +7161,10 @@ async function generateSummary(apiConfig, name, compactionPrompt, messagesToSumm
           // A split driven by size gets its children a retry of their own. A
           // split that IS the retry does not, or a model that will not
           // summarize at any size fans out call after call before giving up.
-          { allowRetry: opts.forceChunk ? false : allowRetry }
+          {
+            allowRetry: opts.forceChunk ? false : allowRetry,
+            ...opts.signal && { signal: opts.signal }
+          }
         )
       )
     );
@@ -7175,7 +7187,8 @@ async function generateSummary(apiConfig, name, compactionPrompt, messagesToSumm
     name,
     compactionPrompt,
     serialized,
-    model
+    model,
+    opts.signal
   );
   if (summaryText === null) {
     return null;
@@ -7203,7 +7216,7 @@ async function generateSummary(apiConfig, name, compactionPrompt, messagesToSumm
     { forceChunk: true, allowRetry: false }
   );
 }
-async function runSummaryCall(apiConfig, name, compactionPrompt, serialized, model) {
+async function runSummaryCall(apiConfig, name, compactionPrompt, serialized, model, signal) {
   const userContent = `Conversation to summarize:
 
 ${serialized}
@@ -7225,7 +7238,8 @@ Write the summary of the conversation above, following your instructions.`;
     // Each summary call carries a unique 100-200KB chunk that is never
     // re-read (parallel siblings can't read each other's in-flight writes
     // either) — a cache write here is pure waste.
-    cachePolicy: "oneshot"
+    cachePolicy: "oneshot",
+    ...signal && { signal }
   })) {
     if (event.type === "text") {
       summaryText += event.text;
@@ -7249,7 +7263,11 @@ Write the summary of the conversation above, following your instructions.`;
     }
   }
   if (!summaryText.trim()) {
-    log10.warn("Empty summary generated", { name });
+    if (signal?.aborted) {
+      log10.info("Summary cancelled", { name });
+    } else {
+      log10.warn("Empty summary generated", { name });
+    }
     return null;
   }
   return summaryText.trim();
@@ -7610,11 +7628,26 @@ function clearSession(state) {
 
 // src/compaction/trigger.ts
 var log12 = createLogger("compaction:trigger");
+var CompactionCancelledError = class extends Error {
+  constructor() {
+    super("Compaction cancelled \u2014 no checkpoint was created.");
+    this.name = "CompactionCancelledError";
+  }
+};
 var pending = null;
 var inflightCompaction = null;
+var inflightAbort = null;
 function getInflightCompaction() {
   return inflightCompaction;
 }
+function cancelInflightCompaction() {
+  if (!inflightCompaction || !inflightAbort) {
+    return false;
+  }
+  log12.info("Cancelling in-flight compaction");
+  inflightAbort.abort();
+  return true;
+}
 function summariesOf(result) {
   const out = [];
   for (const msg of result.checkpoints) {
@@ -7687,10 +7720,13 @@ function triggerCompaction(state, apiConfig, opts = {}) {
   }
   const { blocking = false, requestId, model, origin, toolCallId } = opts;
   listener?.({ type: "started", blocking, requestId, origin, toolCallId });
+  const abort = new AbortController();
+  inflightAbort = abort;
   inflightCompaction = compactConversation(
     state.messages,
     apiConfig,
-    resolveModel("conversationSummarizer", state.models, model)
+    resolveModel("conversationSummarizer", state.models, model),
+    abort.signal
   ).then((result) => {
     pending = result;
     const summaries = summariesOf(result);
@@ -7702,12 +7738,23 @@ function triggerCompaction(state, apiConfig, opts = {}) {
     log12.info("Compaction complete");
     return summaries;
   }).catch((err) => {
-    const message = err.message || "Compaction failed";
-    listener?.({ type: "complete", error: message, requestId });
-    log12.error("Compaction failed", { error: message });
-    throw err;
+    const cancelled = abort.signal.aborted;
+    const message = cancelled ? "Compaction cancelled" : err.message || "Compaction failed";
+    listener?.({
+      type: "complete",
+      error: message,
+      ...cancelled && { cancelled: true },
+      requestId
+    });
+    if (cancelled) {
+      log12.info("Compaction cancelled");
+    } else {
+      log12.error("Compaction failed", { error: message });
+    }
+    throw cancelled ? new CompactionCancelledError() : err;
   }).finally(() => {
     inflightCompaction = null;
+    inflightAbort = null;
   });
   return inflightCompaction;
 }
@@ -9197,6 +9244,11 @@ function writeStats(stats, queue, passiveResults) {
 }
 
 // src/headless/messageQueue.ts
+function holdRestoredUserItems(items) {
+  return items.map(
+    (item) => item.source === "user" ? { ...item, held: true } : item
+  );
+}
 var MessageQueue = class {
   items = [];
   onChange;
@@ -9208,33 +9260,36 @@ var MessageQueue = class {
     this.items.push(item);
     this.onChange?.();
   }
-  shift() {
-    const item = this.items.shift();
+  /**
+   * Index of the first deliverable item, or -1 when there is none.
+   *
+   * Held items are out of the delivery sequence, so the drain skips past them
+   * rather than stopping at them: a message the user parked sits at the head
+   * of the array, and stopping there would strand Remy's own chain steps and
+   * background results queued behind it.
+   */
+  firstDeliverableIndex() {
+    return this.items.findIndex((item) => !item.held);
+  }
+  /** Remove and return the item at `i`; fires onChange. */
+  takeAt(i) {
+    const [item] = this.items.splice(i, 1);
     if (item) {
       this.onChange?.();
     }
     return item;
   }
-  /** Remove and return the first `n` items; fires onChange once. */
-  shiftMany(n) {
-    if (n <= 0) {
+  /** Remove and return `count` items starting at `start`; fires onChange once. */
+  takeRange(start, count) {
+    if (count <= 0) {
       return [];
     }
-    const items = this.items.splice(0, n);
+    const items = this.items.splice(start, count);
     if (items.length > 0) {
       this.onChange?.();
     }
     return items;
   }
-  /** Remove and return all queued items. */
-  drain() {
-    if (this.items.length === 0) {
-      return [];
-    }
-    const all = this.items.splice(0);
-    this.onChange?.();
-    return all;
-  }
   /**
    * Remove all items matching `predicate`. Fires onChange only if something
    * was removed. Returns the removed items.
@@ -9253,6 +9308,49 @@ var MessageQueue = class {
     }
     return removed;
   }
+  /**
+   * Mark matching items `held` — waiting on the user rather than on the agent.
+   * Fires onChange only if something changed. Returns the held items.
+   */
+  holdWhere(predicate) {
+    const held = [];
+    let changed = false;
+    for (const item of this.items) {
+      if (!predicate(item)) {
+        continue;
+      }
+      changed = changed || !item.held;
+      item.held = true;
+      held.push(item);
+    }
+    if (changed) {
+      this.onChange?.();
+    }
+    return held;
+  }
+  /**
+   * Release held items so the normal drain picks them up again — all of them,
+   * or one by command requestId. Fires onChange only if something changed.
+   * Returns the released items.
+   */
+  releaseHeld(id) {
+    const released = [];
+    for (const item of this.items) {
+      if (!item.held || id !== void 0 && item.command.requestId !== id) {
+        continue;
+      }
+      delete item.held;
+      released.push(item);
+    }
+    if (released.length > 0) {
+      this.onChange?.();
+    }
+    return released;
+  }
+  /** Whether anything in the queue will drain on its own (i.e. isn't held). */
+  hasDeliverable() {
+    return this.items.some((item) => !item.held);
+  }
   /**
    * Change a queued item's delivery semantics, keyed by its command
    * requestId. Fires onChange (→ persist + queue_changed) on success.
@@ -9268,14 +9366,35 @@ var MessageQueue = class {
     this.onChange?.();
     return item;
   }
+  /**
+   * Promote an item to ASAP: release any hold, and move it to the head so it
+   * is the next thing delivered. One onChange for all of it.
+   *
+   * Position matters only when no turn is running — mid-turn, ASAP items are
+   * pulled by predicate at the next tool boundary regardless of where they sit
+   * (`takeSteering`), jumping whatever is queued ahead of them. Moving to the
+   * head makes the idle case behave the same way, and matches the card, which
+   * already renders promoted items above everything else.
+   *
+   * Returns the item, or undefined if nothing matches (e.g. it was already
+   * consumed by the running turn).
+   */
+  promoteToFront(id) {
+    const idx = this.items.findIndex((it) => it.command.requestId === id);
+    if (idx === -1) {
+      return void 0;
+    }
+    const [item] = this.items.splice(idx, 1);
+    item.delivery = "asap";
+    delete item.held;
+    this.items.unshift(item);
+    this.onChange?.();
+    return item;
+  }
   /** Copy of current queue contents (for surfacing on events). */
   snapshot() {
     return [...this.items];
   }
-  /** Return the next item without removing it. */
-  peek() {
-    return this.items[0];
-  }
   /** Return the item at index `i` without removing it. */
   peekAt(i) {
     return this.items[i];
@@ -9375,7 +9494,7 @@ var HeadlessSession = class {
     });
     await initOrgContext(this.config);
     const resumed = loadSession(this.state);
-    this.queue = new MessageQueue(loadQueue(), () => {
+    this.queue = new MessageQueue(holdRestoredUserItems(loadQueue()), () => {
       this.persistStats();
       this.emit("queue_changed", { queuedMessages: this.queue.snapshot() });
     });
@@ -9428,13 +9547,16 @@ var HeadlessSession = class {
           });
         }
       } else {
-        const data = event.error ? { error: event.error } : {};
+        const data = {
+          ...event.error && { error: event.error },
+          ...event.cancelled && { cancelled: true }
+        };
         this.emit("compaction_complete", data, event.requestId);
         if (this.syntheticCompactionId) {
           const id = this.syntheticCompactionId;
           this.syntheticCompactionId = null;
-          const result = event.error ? `Error: ${event.error}` : formatSummariesResult(event.summaries ?? []);
-          const isError = !!event.error;
+          const result = event.cancelled ? "Compaction cancelled \u2014 no checkpoint was created." : event.error ? `Error: ${event.error}` : formatSummariesResult(event.summaries ?? []);
+          const isError = !!event.error && !event.cancelled;
           for (let i = this.state.messages.length - 1; i >= 0; i--) {
             const msg = this.state.messages[i];
             if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
@@ -10115,7 +10237,11 @@ var HeadlessSession = class {
     this.applyPendingBlockUpdates();
   }
   async handleMessage(parsed, requestId) {
-    if (this.running || getInflightCompaction()) {
+    const foldIn = !this.running && !getInflightCompaction() && this.queue.length > 0 && !isAutomatedMessage(parsed.text ?? "");
+    if (foldIn) {
+      this.queue.releaseHeld();
+    }
+    if (this.running || getInflightCompaction() || foldIn) {
       const command = { ...parsed };
       if (requestId && command.requestId === void 0) {
         command.requestId = requestId;
@@ -10152,8 +10278,9 @@ var HeadlessSession = class {
     return item.source === "user" && isAutomatedMessage(item.command.text ?? "");
   }
   /**
-   * Drain the queue in strict FIFO order. Caller must hold `running = true`.
-   * User messages arriving during the drain will be enqueued behind current items.
+   * Drain the queue in FIFO order over its deliverable items. Caller must hold
+   * `running = true`. User messages arriving during the drain will be enqueued
+   * behind current items.
    *
    * The queue serves two purposes with opposite delivery semantics:
    * - Sequencer: chain steps and sentinel-bearing user items are pipeline
@@ -10163,12 +10290,21 @@ var HeadlessSession = class {
    *   merged turn, so the model reconciles all of it at once instead of
    *   burning a full turn per item (and possibly executing instructions a
    *   later queued message already amended).
+   *
+   * Held items are not in the delivery sequence at all: the drain starts at the
+   * first deliverable item and never merges across a held one. It skips rather
+   * than stops because a held message sits at the head of the array — stopping
+   * there would strand the chain steps and background results behind it.
    */
   async drainQueueLoop() {
-    while (this.queue.length > 0) {
-      const head = this.queue.peek();
+    for (; ; ) {
+      const at = this.queue.firstDeliverableIndex();
+      if (at === -1) {
+        return;
+      }
+      const head = this.queue.peekAt(at);
       if (head.command.action === "compact") {
-        this.queue.shift();
+        this.queue.takeAt(at);
         await triggerCompaction(this.state, this.config, {
           blocking: true,
           requestId: head.command.requestId,
@@ -10180,13 +10316,13 @@ var HeadlessSession = class {
         continue;
       }
       if (head.source === "chain") {
-        const item = this.queue.shift();
+        const item = this.queue.takeAt(at);
         const rid = item.command.requestId ?? `chain-${Date.now()}`;
         await this.runSingleTurn(item.command, rid, true);
         continue;
       }
       if (this.isDrainBarrier(head)) {
-        const item = this.queue.shift();
+        const item = this.queue.takeAt(at);
         const rid = item.command.requestId ?? `user-${Date.now()}`;
         await this.runSingleTurn(item.command, rid, false, true);
         continue;
@@ -10194,8 +10330,8 @@ var HeadlessSession = class {
       let n = 1;
       let batchOb = head.command.onboardingState;
       for (; ; n++) {
-        const it = this.queue.peekAt(n);
-        if (!it || it.source === "chain" || this.isDrainBarrier(it)) {
+        const it = this.queue.peekAt(at + n);
+        if (!it || it.held || it.source === "chain" || this.isDrainBarrier(it)) {
           break;
         }
         const ob = it.command.onboardingState;
@@ -10206,7 +10342,7 @@ var HeadlessSession = class {
           batchOb = ob;
         }
       }
-      const batch = this.queue.shiftMany(n);
+      const batch = this.queue.takeRange(at, n);
       await this.runMergedTurn(batch);
     }
   }
@@ -10216,7 +10352,7 @@ var HeadlessSession = class {
    * and by kickDrain (background-completion-initiated).
    */
   async resumeQueue() {
-    if (this.running || this.queue.length === 0) {
+    if (this.running || !this.queue.hasDeliverable()) {
       return;
     }
     this.running = true;
@@ -10235,7 +10371,7 @@ var HeadlessSession = class {
    * racing any currently-synchronous path.
    */
   kickDrain() {
-    if (this.running || this.queue.length === 0) {
+    if (this.running || !this.queue.hasDeliverable()) {
       return;
     }
     setTimeout(() => this.resumeQueue(), 0);
@@ -10264,28 +10400,42 @@ var HeadlessSession = class {
     };
   }
   /**
-   * Cancel the running turn and flush the follow-ups that belonged to it
-   * (`chain`/`background`), while preserving `source: 'user'` items — those are
-   * independent user intent, not tied to the aborted run. The preserved user
-   * messages run next: `executeTurn` swallows the abort, so `handleMessage`
-   * falls through to `drainQueueLoop` with `running` still held. Returns the
-   * flushed items (for the cancel command's resume/discard UX).
+   * Stop everything the user can see running: the turn, an in-flight
+   * compaction, and any external tool waiting on a result. Flushes the
+   * follow-ups that belonged to the turn (`chain`/`background`) and HOLDS the
+   * `source: 'user'` items — those are independent user intent, so they're
+   * kept, but they no longer run on their own.
+   *
+   * Holding is the difference between Stop working and Stop looking broken.
+   * These items used to drain immediately: `executeTurn` swallows the abort,
+   * so `handleMessage` fell through to `drainQueueLoop` with `running` still
+   * held and the next turn began in the same tick — the spinner never stopped,
+   * and every additional press hit a turn that had just started. They now wait
+   * in the queue card until the user sends again or promotes one.
    *
-   * Messages already absorbed into the in-flight merged turn are NOT
-   * preserved — they were delivered into the turn that's being cancelled and
-   * each gets a `{cancelled, absorbed:true}` terminal. Only items still
-   * sitting in the queue survive.
+   * A compaction is cancelled here too, unconditionally. It gates every queued
+   * message and outlives the turn that started it, so leaving it running means
+   * Stop can't reach idle. The cost is the summary work in flight; the forced
+   * gate re-compacts on the next turn if the context is still too big.
+   *
+   * Messages already absorbed into the in-flight merged turn are NOT held —
+   * they were delivered into the turn that's being cancelled and each gets a
+   * `{cancelled, absorbed:true}` terminal. Only items still sitting in the
+   * queue survive.
    */
   handleCancel() {
     if (this.currentAbort) {
       this.currentAbort.abort();
     }
+    const cancelledCompaction = cancelInflightCompaction();
     for (const [id, pending2] of this.pendingTools) {
       clearTimeout(pending2.timeout);
       pending2.resolve(USER_CANCELLED_RESULT);
       this.pendingTools.delete(id);
     }
-    return this.queue.removeWhere((item) => item.source !== "user");
+    const flushed = this.queue.removeWhere((item) => item.source !== "user");
+    const held = this.queue.holdWhere((item) => item.source === "user");
+    return { flushed, held, cancelledCompaction };
   }
   /**
    * Remove pending queued messages — all user messages, or one by id.
@@ -10394,12 +10544,14 @@ var HeadlessSession = class {
       return;
     }
     if (action === "cancel") {
-      const cancelled = this.handleCancel();
+      const { flushed, held, cancelledCompaction } = this.handleCancel();
       this.emit(
         "completed",
         {
           success: true,
-          ...cancelled.length > 0 && { cancelledMessages: cancelled }
+          ...flushed.length > 0 && { cancelledMessages: flushed },
+          ...held.length > 0 && { heldMessages: held },
+          ...cancelledCompaction && { cancelledCompaction: true }
         },
         requestId
       );
@@ -10438,7 +10590,12 @@ var HeadlessSession = class {
         );
         return;
       }
-      this.queue.setDelivery(id, delivery);
+      if (delivery === "asap") {
+        this.queue.promoteToFront(id);
+        this.kickDrain();
+      } else {
+        this.queue.setDelivery(id, delivery);
+      }
       this.emit("completed", { success: true }, requestId);
       return;
     }
@@ -10504,7 +10661,7 @@ var HeadlessSession = class {
         }
         this.emit("completed", { success: true }, requestId);
       } catch (err) {
-        const error = err.message || "Compaction failed";
+        const error = err instanceof CompactionCancelledError ? "cancelled" : err.message || "Compaction failed";
         this.emit("completed", { success: false, error }, requestId);
       }
       return;
@@ -10522,7 +10679,7 @@ var HeadlessSession = class {
         );
         return;
       }
-      if (this.queue.length === 0) {
+      if (!this.queue.hasDeliverable()) {
         this.emit("completed", { success: true }, requestId);
         return;
       }

package/dist/index.js

@@ -195,12 +195,17 @@ async function* streamChat(params) {
       }
       const isStall = err?.message === "stream_stall";
       const errorMessage = isStall ? "Stream stalled \u2014 no data received for 5 minutes" : `Network error: stream interrupted \u2014 ${err?.message ?? "unknown"}`;
-      log.error(isStall ? "Stream stalled" : "Stream interrupted", {
-        requestId,
-        ...subAgentId && { subAgentId },
-        durationMs: Date.now() - startTime,
-        error: errorMessage
-      });
+      const wasAborted = !isStall && !!signal?.aborted;
+      const logAt = wasAborted ? log.warn : log.error;
+      logAt(
+        wasAborted ? "Request aborted mid-stream" : isStall ? "Stream stalled" : "Stream interrupted",
+        {
+          requestId,
+          ...subAgentId && { subAgentId },
+          durationMs: Date.now() - startTime,
+          error: errorMessage
+        }
+      );
       yield { type: "error", error: errorMessage };
       return;
     }
@@ -1677,7 +1682,7 @@ var init_sentinel = __esm({
 });
 
 // src/compaction/index.ts
-async function compactConversation(messages, apiConfig, model) {
+async function compactConversation(messages, apiConfig, model, signal) {
   const endIndex = findSafeInsertionPoint(messages);
   const boundary = endIndex > 0 ? messages[endIndex - 1] : null;
   const summaries = [];
@@ -1694,7 +1699,8 @@ async function compactConversation(messages, apiConfig, model) {
         "conversation",
         CONVERSATION_SUMMARY_PROMPT,
         conversationMessages,
-        model
+        model,
+        { signal }
       ).then((text) => {
         if (text) {
           summaries.push({ name: "conversation", text });
@@ -1717,7 +1723,8 @@ async function compactConversation(messages, apiConfig, model) {
           name,
           SUBAGENT_SUMMARY_PROMPT,
           subagentMessages,
-          model
+          model,
+          { signal }
         ).then((text) => {
           if (text) {
             summaries.push({ name, text });
@@ -1733,7 +1740,7 @@ async function compactConversation(messages, apiConfig, model) {
   await Promise.all(tasks);
   if (conversationFailed) {
     throw new Error(
-      "Could not summarize the conversation \u2014 the model did not return a usable summary. History left intact."
+      signal?.aborted ? "Compaction cancelled. History left intact." : "Could not summarize the conversation \u2014 the model did not return a usable summary. History left intact."
     );
   }
   const recent = collectRecentNarrative(conversationMessages);
@@ -1969,7 +1976,10 @@ async function generateSummary(apiConfig, name, compactionPrompt, messagesToSumm
           // A split driven by size gets its children a retry of their own. A
           // split that IS the retry does not, or a model that will not
           // summarize at any size fans out call after call before giving up.
-          { allowRetry: opts.forceChunk ? false : allowRetry }
+          {
+            allowRetry: opts.forceChunk ? false : allowRetry,
+            ...opts.signal && { signal: opts.signal }
+          }
         )
       )
     );
@@ -1992,7 +2002,8 @@ async function generateSummary(apiConfig, name, compactionPrompt, messagesToSumm
     name,
     compactionPrompt,
     serialized,
-    model
+    model,
+    opts.signal
   );
   if (summaryText === null) {
     return null;
@@ -2020,7 +2031,7 @@ async function generateSummary(apiConfig, name, compactionPrompt, messagesToSumm
     { forceChunk: true, allowRetry: false }
   );
 }
-async function runSummaryCall(apiConfig, name, compactionPrompt, serialized, model) {
+async function runSummaryCall(apiConfig, name, compactionPrompt, serialized, model, signal) {
   const userContent = `Conversation to summarize:
 
 ${serialized}
@@ -2042,7 +2053,8 @@ Write the summary of the conversation above, following your instructions.`;
     // Each summary call carries a unique 100-200KB chunk that is never
     // re-read (parallel siblings can't read each other's in-flight writes
     // either) — a cache write here is pure waste.
-    cachePolicy: "oneshot"
+    cachePolicy: "oneshot",
+    ...signal && { signal }
   })) {
     if (event.type === "text") {
       summaryText += event.text;
@@ -2066,7 +2078,11 @@ Write the summary of the conversation above, following your instructions.`;
     }
   }
   if (!summaryText.trim()) {
-    log2.warn("Empty summary generated", { name });
+    if (signal?.aborted) {
+      log2.info("Summary cancelled", { name });
+    } else {
+      log2.warn("Empty summary generated", { name });
+    }
     return null;
   }
   return summaryText.trim();
@@ -2861,6 +2877,14 @@ var init_session = __esm({
 function getInflightCompaction() {
   return inflightCompaction;
 }
+function cancelInflightCompaction() {
+  if (!inflightCompaction || !inflightAbort) {
+    return false;
+  }
+  log4.info("Cancelling in-flight compaction");
+  inflightAbort.abort();
+  return true;
+}
 function summariesOf(result) {
   const out = [];
   for (const msg of result.checkpoints) {
@@ -2927,10 +2951,13 @@ function triggerCompaction(state, apiConfig, opts = {}) {
   }
   const { blocking = false, requestId, model, origin, toolCallId } = opts;
   listener?.({ type: "started", blocking, requestId, origin, toolCallId });
+  const abort = new AbortController();
+  inflightAbort = abort;
   inflightCompaction = compactConversation(
     state.messages,
     apiConfig,
-    resolveModel("conversationSummarizer", state.models, model)
+    resolveModel("conversationSummarizer", state.models, model),
+    abort.signal
   ).then((result) => {
     pending = result;
     const summaries = summariesOf(result);
@@ -2942,16 +2969,27 @@ function triggerCompaction(state, apiConfig, opts = {}) {
     log4.info("Compaction complete");
     return summaries;
   }).catch((err) => {
-    const message = err.message || "Compaction failed";
-    listener?.({ type: "complete", error: message, requestId });
-    log4.error("Compaction failed", { error: message });
-    throw err;
+    const cancelled = abort.signal.aborted;
+    const message = cancelled ? "Compaction cancelled" : err.message || "Compaction failed";
+    listener?.({
+      type: "complete",
+      error: message,
+      ...cancelled && { cancelled: true },
+      requestId
+    });
+    if (cancelled) {
+      log4.info("Compaction cancelled");
+    } else {
+      log4.error("Compaction failed", { error: message });
+    }
+    throw cancelled ? new CompactionCancelledError() : err;
   }).finally(() => {
     inflightCompaction = null;
+    inflightAbort = null;
   });
   return inflightCompaction;
 }
-var log4, pending, inflightCompaction, SUMMARY_SECTION_LABELS, listener;
+var log4, CompactionCancelledError, pending, inflightCompaction, inflightAbort, SUMMARY_SECTION_LABELS, listener;
 var init_trigger = __esm({
   "src/compaction/trigger.ts"() {
     "use strict";
@@ -2960,8 +2998,15 @@ var init_trigger = __esm({
     init_surfaces();
     init_session();
     log4 = createLogger("compaction:trigger");
+    CompactionCancelledError = class extends Error {
+      constructor() {
+        super("Compaction cancelled \u2014 no checkpoint was created.");
+        this.name = "CompactionCancelledError";
+      }
+    };
     pending = null;
     inflightCompaction = null;
+    inflightAbort = null;
     SUMMARY_SECTION_LABELS = {
       conversation: "Conversation",
       visualDesignExpert: "Design Agent Thread",
@@ -3018,7 +3063,9 @@ var init_compactConversation = __esm({
           onBackgroundComplete?.(
             toolCallId,
             "compactConversation",
-            `Error: ${err.message || "Compaction failed"}`
+            // A cancel is the user's own doing — report it as an outcome, not as
+            // an error the block renders as a failure.
+            err instanceof CompactionCancelledError ? err.message : `Error: ${err.message || "Compaction failed"}`
           );
         }).finally(() => {
           toolRegistry?.unregister(toolCallId);
@@ -10147,6 +10194,11 @@ var init_stats = __esm({
 });
 
 // src/headless/messageQueue.ts
+function holdRestoredUserItems(items) {
+  return items.map(
+    (item) => item.source === "user" ? { ...item, held: true } : item
+  );
+}
 var MessageQueue;
 var init_messageQueue = __esm({
   "src/headless/messageQueue.ts"() {
@@ -10162,33 +10214,36 @@ var init_messageQueue = __esm({
         this.items.push(item);
         this.onChange?.();
       }
-      shift() {
-        const item = this.items.shift();
+      /**
+       * Index of the first deliverable item, or -1 when there is none.
+       *
+       * Held items are out of the delivery sequence, so the drain skips past them
+       * rather than stopping at them: a message the user parked sits at the head
+       * of the array, and stopping there would strand Remy's own chain steps and
+       * background results queued behind it.
+       */
+      firstDeliverableIndex() {
+        return this.items.findIndex((item) => !item.held);
+      }
+      /** Remove and return the item at `i`; fires onChange. */
+      takeAt(i) {
+        const [item] = this.items.splice(i, 1);
         if (item) {
           this.onChange?.();
         }
         return item;
       }
-      /** Remove and return the first `n` items; fires onChange once. */
-      shiftMany(n) {
-        if (n <= 0) {
+      /** Remove and return `count` items starting at `start`; fires onChange once. */
+      takeRange(start, count) {
+        if (count <= 0) {
           return [];
         }
-        const items = this.items.splice(0, n);
+        const items = this.items.splice(start, count);
         if (items.length > 0) {
           this.onChange?.();
         }
         return items;
       }
-      /** Remove and return all queued items. */
-      drain() {
-        if (this.items.length === 0) {
-          return [];
-        }
-        const all = this.items.splice(0);
-        this.onChange?.();
-        return all;
-      }
       /**
        * Remove all items matching `predicate`. Fires onChange only if something
        * was removed. Returns the removed items.
@@ -10207,6 +10262,49 @@ var init_messageQueue = __esm({
         }
         return removed;
       }
+      /**
+       * Mark matching items `held` — waiting on the user rather than on the agent.
+       * Fires onChange only if something changed. Returns the held items.
+       */
+      holdWhere(predicate) {
+        const held = [];
+        let changed = false;
+        for (const item of this.items) {
+          if (!predicate(item)) {
+            continue;
+          }
+          changed = changed || !item.held;
+          item.held = true;
+          held.push(item);
+        }
+        if (changed) {
+          this.onChange?.();
+        }
+        return held;
+      }
+      /**
+       * Release held items so the normal drain picks them up again — all of them,
+       * or one by command requestId. Fires onChange only if something changed.
+       * Returns the released items.
+       */
+      releaseHeld(id) {
+        const released = [];
+        for (const item of this.items) {
+          if (!item.held || id !== void 0 && item.command.requestId !== id) {
+            continue;
+          }
+          delete item.held;
+          released.push(item);
+        }
+        if (released.length > 0) {
+          this.onChange?.();
+        }
+        return released;
+      }
+      /** Whether anything in the queue will drain on its own (i.e. isn't held). */
+      hasDeliverable() {
+        return this.items.some((item) => !item.held);
+      }
       /**
        * Change a queued item's delivery semantics, keyed by its command
        * requestId. Fires onChange (→ persist + queue_changed) on success.
@@ -10222,14 +10320,35 @@ var init_messageQueue = __esm({
         this.onChange?.();
         return item;
       }
+      /**
+       * Promote an item to ASAP: release any hold, and move it to the head so it
+       * is the next thing delivered. One onChange for all of it.
+       *
+       * Position matters only when no turn is running — mid-turn, ASAP items are
+       * pulled by predicate at the next tool boundary regardless of where they sit
+       * (`takeSteering`), jumping whatever is queued ahead of them. Moving to the
+       * head makes the idle case behave the same way, and matches the card, which
+       * already renders promoted items above everything else.
+       *
+       * Returns the item, or undefined if nothing matches (e.g. it was already
+       * consumed by the running turn).
+       */
+      promoteToFront(id) {
+        const idx = this.items.findIndex((it) => it.command.requestId === id);
+        if (idx === -1) {
+          return void 0;
+        }
+        const [item] = this.items.splice(idx, 1);
+        item.delivery = "asap";
+        delete item.held;
+        this.items.unshift(item);
+        this.onChange?.();
+        return item;
+      }
       /** Copy of current queue contents (for surfacing on events). */
       snapshot() {
         return [...this.items];
       }
-      /** Return the next item without removing it. */
-      peek() {
-        return this.items[0];
-      }
       /** Return the item at index `i` without removing it. */
       peekAt(i) {
         return this.items[i];
@@ -10357,7 +10476,7 @@ var init_headless = __esm({
         });
         await initOrgContext(this.config);
         const resumed = loadSession(this.state);
-        this.queue = new MessageQueue(loadQueue(), () => {
+        this.queue = new MessageQueue(holdRestoredUserItems(loadQueue()), () => {
           this.persistStats();
           this.emit("queue_changed", { queuedMessages: this.queue.snapshot() });
         });
@@ -10410,13 +10529,16 @@ var init_headless = __esm({
               });
             }
           } else {
-            const data = event.error ? { error: event.error } : {};
+            const data = {
+              ...event.error && { error: event.error },
+              ...event.cancelled && { cancelled: true }
+            };
             this.emit("compaction_complete", data, event.requestId);
             if (this.syntheticCompactionId) {
               const id = this.syntheticCompactionId;
               this.syntheticCompactionId = null;
-              const result = event.error ? `Error: ${event.error}` : formatSummariesResult(event.summaries ?? []);
-              const isError = !!event.error;
+              const result = event.cancelled ? "Compaction cancelled \u2014 no checkpoint was created." : event.error ? `Error: ${event.error}` : formatSummariesResult(event.summaries ?? []);
+              const isError = !!event.error && !event.cancelled;
               for (let i = this.state.messages.length - 1; i >= 0; i--) {
                 const msg = this.state.messages[i];
                 if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
@@ -11097,7 +11219,11 @@ var init_headless = __esm({
         this.applyPendingBlockUpdates();
       }
       async handleMessage(parsed, requestId) {
-        if (this.running || getInflightCompaction()) {
+        const foldIn = !this.running && !getInflightCompaction() && this.queue.length > 0 && !isAutomatedMessage(parsed.text ?? "");
+        if (foldIn) {
+          this.queue.releaseHeld();
+        }
+        if (this.running || getInflightCompaction() || foldIn) {
           const command = { ...parsed };
           if (requestId && command.requestId === void 0) {
             command.requestId = requestId;
@@ -11134,8 +11260,9 @@ var init_headless = __esm({
         return item.source === "user" && isAutomatedMessage(item.command.text ?? "");
       }
       /**
-       * Drain the queue in strict FIFO order. Caller must hold `running = true`.
-       * User messages arriving during the drain will be enqueued behind current items.
+       * Drain the queue in FIFO order over its deliverable items. Caller must hold
+       * `running = true`. User messages arriving during the drain will be enqueued
+       * behind current items.
        *
        * The queue serves two purposes with opposite delivery semantics:
        * - Sequencer: chain steps and sentinel-bearing user items are pipeline
@@ -11145,12 +11272,21 @@ var init_headless = __esm({
        *   merged turn, so the model reconciles all of it at once instead of
        *   burning a full turn per item (and possibly executing instructions a
        *   later queued message already amended).
+       *
+       * Held items are not in the delivery sequence at all: the drain starts at the
+       * first deliverable item and never merges across a held one. It skips rather
+       * than stops because a held message sits at the head of the array — stopping
+       * there would strand the chain steps and background results behind it.
        */
       async drainQueueLoop() {
-        while (this.queue.length > 0) {
-          const head = this.queue.peek();
+        for (; ; ) {
+          const at = this.queue.firstDeliverableIndex();
+          if (at === -1) {
+            return;
+          }
+          const head = this.queue.peekAt(at);
           if (head.command.action === "compact") {
-            this.queue.shift();
+            this.queue.takeAt(at);
             await triggerCompaction(this.state, this.config, {
               blocking: true,
               requestId: head.command.requestId,
@@ -11162,13 +11298,13 @@ var init_headless = __esm({
             continue;
           }
           if (head.source === "chain") {
-            const item = this.queue.shift();
+            const item = this.queue.takeAt(at);
             const rid = item.command.requestId ?? `chain-${Date.now()}`;
             await this.runSingleTurn(item.command, rid, true);
             continue;
           }
           if (this.isDrainBarrier(head)) {
-            const item = this.queue.shift();
+            const item = this.queue.takeAt(at);
             const rid = item.command.requestId ?? `user-${Date.now()}`;
             await this.runSingleTurn(item.command, rid, false, true);
             continue;
@@ -11176,8 +11312,8 @@ var init_headless = __esm({
           let n = 1;
           let batchOb = head.command.onboardingState;
           for (; ; n++) {
-            const it = this.queue.peekAt(n);
-            if (!it || it.source === "chain" || this.isDrainBarrier(it)) {
+            const it = this.queue.peekAt(at + n);
+            if (!it || it.held || it.source === "chain" || this.isDrainBarrier(it)) {
               break;
             }
             const ob = it.command.onboardingState;
@@ -11188,7 +11324,7 @@ var init_headless = __esm({
               batchOb = ob;
             }
           }
-          const batch = this.queue.shiftMany(n);
+          const batch = this.queue.takeRange(at, n);
           await this.runMergedTurn(batch);
         }
       }
@@ -11198,7 +11334,7 @@ var init_headless = __esm({
        * and by kickDrain (background-completion-initiated).
        */
       async resumeQueue() {
-        if (this.running || this.queue.length === 0) {
+        if (this.running || !this.queue.hasDeliverable()) {
           return;
         }
         this.running = true;
@@ -11217,7 +11353,7 @@ var init_headless = __esm({
        * racing any currently-synchronous path.
        */
       kickDrain() {
-        if (this.running || this.queue.length === 0) {
+        if (this.running || !this.queue.hasDeliverable()) {
           return;
         }
         setTimeout(() => this.resumeQueue(), 0);
@@ -11246,28 +11382,42 @@ var init_headless = __esm({
         };
       }
       /**
-       * Cancel the running turn and flush the follow-ups that belonged to it
-       * (`chain`/`background`), while preserving `source: 'user'` items — those are
-       * independent user intent, not tied to the aborted run. The preserved user
-       * messages run next: `executeTurn` swallows the abort, so `handleMessage`
-       * falls through to `drainQueueLoop` with `running` still held. Returns the
-       * flushed items (for the cancel command's resume/discard UX).
+       * Stop everything the user can see running: the turn, an in-flight
+       * compaction, and any external tool waiting on a result. Flushes the
+       * follow-ups that belonged to the turn (`chain`/`background`) and HOLDS the
+       * `source: 'user'` items — those are independent user intent, so they're
+       * kept, but they no longer run on their own.
+       *
+       * Holding is the difference between Stop working and Stop looking broken.
+       * These items used to drain immediately: `executeTurn` swallows the abort,
+       * so `handleMessage` fell through to `drainQueueLoop` with `running` still
+       * held and the next turn began in the same tick — the spinner never stopped,
+       * and every additional press hit a turn that had just started. They now wait
+       * in the queue card until the user sends again or promotes one.
        *
-       * Messages already absorbed into the in-flight merged turn are NOT
-       * preserved — they were delivered into the turn that's being cancelled and
-       * each gets a `{cancelled, absorbed:true}` terminal. Only items still
-       * sitting in the queue survive.
+       * A compaction is cancelled here too, unconditionally. It gates every queued
+       * message and outlives the turn that started it, so leaving it running means
+       * Stop can't reach idle. The cost is the summary work in flight; the forced
+       * gate re-compacts on the next turn if the context is still too big.
+       *
+       * Messages already absorbed into the in-flight merged turn are NOT held —
+       * they were delivered into the turn that's being cancelled and each gets a
+       * `{cancelled, absorbed:true}` terminal. Only items still sitting in the
+       * queue survive.
        */
       handleCancel() {
         if (this.currentAbort) {
           this.currentAbort.abort();
         }
+        const cancelledCompaction = cancelInflightCompaction();
         for (const [id, pending2] of this.pendingTools) {
           clearTimeout(pending2.timeout);
           pending2.resolve(USER_CANCELLED_RESULT);
           this.pendingTools.delete(id);
         }
-        return this.queue.removeWhere((item) => item.source !== "user");
+        const flushed = this.queue.removeWhere((item) => item.source !== "user");
+        const held = this.queue.holdWhere((item) => item.source === "user");
+        return { flushed, held, cancelledCompaction };
       }
       /**
        * Remove pending queued messages — all user messages, or one by id.
@@ -11376,12 +11526,14 @@ var init_headless = __esm({
           return;
         }
         if (action === "cancel") {
-          const cancelled = this.handleCancel();
+          const { flushed, held, cancelledCompaction } = this.handleCancel();
           this.emit(
             "completed",
             {
               success: true,
-              ...cancelled.length > 0 && { cancelledMessages: cancelled }
+              ...flushed.length > 0 && { cancelledMessages: flushed },
+              ...held.length > 0 && { heldMessages: held },
+              ...cancelledCompaction && { cancelledCompaction: true }
             },
             requestId
           );
@@ -11420,7 +11572,12 @@ var init_headless = __esm({
             );
             return;
           }
-          this.queue.setDelivery(id, delivery);
+          if (delivery === "asap") {
+            this.queue.promoteToFront(id);
+            this.kickDrain();
+          } else {
+            this.queue.setDelivery(id, delivery);
+          }
           this.emit("completed", { success: true }, requestId);
           return;
         }
@@ -11486,7 +11643,7 @@ var init_headless = __esm({
             }
             this.emit("completed", { success: true }, requestId);
           } catch (err) {
-            const error = err.message || "Compaction failed";
+            const error = err instanceof CompactionCancelledError ? "cancelled" : err.message || "Compaction failed";
             this.emit("completed", { success: false, error }, requestId);
           }
           return;
@@ -11504,7 +11661,7 @@ var init_headless = __esm({
             );
             return;
           }
-          if (this.queue.length === 0) {
+          if (!this.queue.hasDeliverable()) {
             this.emit("completed", { success: true }, requestId);
             return;
           }

package/package.json

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