@mindstudio-ai/remy 0.1.293 → 0.1.295

package/dist/automatedActions/reviseFromAnnotatedImage.md

@@ -2,4 +2,6 @@
   trigger: reviseFromAnnotatedImage
 ---
 
-This is an automated message triggered by the user submitting a screenshot of the app that they have annotated with text notes. Please analyze the provided image and make the requested revisions to the web interface.
+This is an automated message triggered by the user annotating a screenshot of the app with revision notes. The attached image is a capture of the app's UI with the user's annotations drawn on top: pink (#DD2590) markers — a small pin dot or a dashed rectangle outlining an area — each with a pink speech bubble containing the note text in white. The image may be a vertical crop of a scrolled page, not necessarily the top of it.
+
+The message params include a `notes` array with each annotation's exact text and position (pixel coordinates in the attached image; pins have `x`/`y`, areas add `w`/`h`). Treat the `notes` params as the authoritative note text and use the image to see what each note points at. Make the requested revisions to the web interface.

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;
     }
@@ -1387,7 +1392,7 @@ async function listRecursive(dir) {
 var presentPublishPlanTool = {
   definition: {
     name: "presentPublishPlan",
-    description: "Present a publish changelog to the user for approval \u2014 the consent gate of the release flow, used when the user has asked to publish (the Publish button or an explicit chat request; the `publishing` skill covers the full sequence). Write a clear markdown summary of what changed since the last deploy. The user will see this in a full-screen view and can approve or dismiss. Call this BEFORE committing or pushing.",
+    description: "Present a publish changelog to the user for approval \u2014 the consent gate of the release flow, used when the user has asked to publish (the Publish button or an explicit chat request; the `publishing` skill covers the full sequence). Write a clear markdown summary of what changed since the last deploy. The user reviews this in the editor area and can approve or dismiss. Call this BEFORE committing or pushing.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1522,7 +1527,7 @@ var markBuildCompleteTool = {
 var promptUserTool = {
   definition: {
     name: "promptUser",
-    description: 'Ask the user structured questions. Choose type first: "form" for structured intake (5+ questions, takes over screen), "inline" for quick clarifications or confirmations. Blocks until the user responds. Result contains `_dismissed: true` if the user dismisses without answering.',
+    description: 'Ask the user structured questions. Choose type first: "form" for structured intake (5+ questions, opens as a full form in the editor area), "inline" for quick clarifications or confirmations. Blocks until the user responds. Result contains `_dismissed: true` if the user dismisses without answering.',
     inputSchema: {
       type: "object",
       properties: {
@@ -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;
       }