@mindstudio-ai/remy 0.1.292 → 0.1.294

package/dist/automatedActions/publish.md

@@ -4,17 +4,4 @@
 
 This is an automated action triggered by the user pressing "Publish" in the editor.
 
-Pressing Publish is the user's decision to ship. The work is finished, and they've watched it come together in the preview throughout the session — now they're asking you to deploy it to `main` (which triggers a production build). Your job is to describe what's going out and ship it.
-
-Read what's changed since the last push — the diffs and commits — and turn it into a user-friendly changelog with `presentPublishPlan`: a plain-language summary of what's new ("added vendor approval workflow", "fixed invoice totals", "updated the dashboard layout"). Reference specific code or file paths only when it helps clarity. This is what the user sees before deploying.
-
-If approved:
-- Stage and commit any uncommitted changes with a clean, descriptive commit message. If the committed work resolves any open issues (`mindstudio-prod issues`), reference them in the commit message with a closing keyword — `fixes #42`, `closes #7` — so the deploy closes them automatically once it goes live.
-- Push to main
-- Use `mindstudio-prod releases wait` to poll the build until it completes. Let the user know it's deploying, then report back when it's live.
-- Once the deploy is live, scale the close-out to what shipped — the changelog you just wrote is the measure. For a meaningful release (new features, interfaces, real behavior changes): dispatch `specSync` with a brief batching everything that changed this session and `refreshBuildOverview: true` (it reconciles the spec, then re-authors the Build Overview from it), and notify `productVision` about what shipped so the roadmap and pitch deck stay current — both run in the background, so hand off and move on without waiting. For a hotfix or small tweak, skip the ceremony: a plain `specSync` (no flag) only if documented behavior actually changed.
-- Once deployed, offer to help with next steps. This includes technical steps likesetting up a custom domain (`mindstudio-prod domains`), checking for errors (`mindstudio-prod requests stats`), seeding production data (`mindstudio-prod db`), managing env vars/secrets, or anything else they need for launch. It also includes going above and beyond and helping holistically. If it's the initial deploy, offer to help create collateral to announce the launch (e.g., an image for sharing on social media, text copy for a post, etc); if it's a meaningful incremental update, an annoucement post or something similar - go above and beyond here to help the user see that you care about the product from end-to-end, not just writing code! They will be appreciative, grateful, and pleased with your creativity here. Refer to the design guidance in the spec for how to talk about the product, and consider consulting the design expert to generate images or other marketing collateral.
-
-After everything is done, if this was a meaningful release, call `compactConversation` to summarize the session and free up context for the next phase of work. After a hotfix, don't bother.
-
-If dismissed, acknowledge and do nothing.
+Pressing Publish is the user's decision to ship what they've watched come together in the preview. Load the `publishing` skill with loadSkill and run the release it describes — changelog approval first, then ship.

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. 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 will see this in a full-screen view and can approve or dismiss. Call this BEFORE committing or pushing.",
     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;
       }

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;
     }
@@ -867,7 +872,7 @@ var init_presentPublishPlan = __esm({
     presentPublishPlanTool = {
       definition: {
         name: "presentPublishPlan",
-        description: "Present a publish changelog to the user for approval. 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 will see this in a full-screen view and can approve or dismiss. Call this BEFORE committing or pushing.",
         inputSchema: {
           type: "object",
           properties: {
@@ -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/dist/prompt/skills/publishing.md

@@ -0,0 +1,36 @@
+---
+name: Publishing & Releases
+what: Shipping to production is a release moment, not just a git push — a user-approved changelog (`presentPublishPlan`) gates the deploy, then commit → push to main → watch the build go live, then a close-out scaled to what shipped (spec sync, roadmap/pitch updates, launch collateral, next steps). Publishing happens at the user's ask, either the Publish button or an explicit request in chat.
+when: The user wants to ship — the Publish automated action fired, or they asked in chat ("publish", "deploy", "ship it", "push it live"). Load BEFORE presenting a changelog, committing, or pushing to main.
+---
+
+# Publishing
+
+Publishing deploys the app to `main`, which triggers a production build. It is the user's decision to ship — it happens when they press Publish in the editor (which arrives as an automated action) or ask you directly in chat. The steps are the same either way, and they run in order: the changelog is the consent moment, so nothing is committed or pushed until it's approved.
+
+If the user wants to see the work before it goes live, push a feature branch instead: that builds a preview at its own URL (`previewUrl` in the `releases wait` result) against a copy of the data, and publishing later is the same flow from `main`.
+
+## 1. Present the changelog
+
+Read what's changed since the last push — the diffs and commits — and turn it into a user-friendly changelog with `presentPublishPlan`: a plain-language summary of what's new ("added vendor approval workflow", "fixed invoice totals", "updated the dashboard layout"). Reference specific code or file paths only when it helps clarity. This is what the user sees, full-screen, before anything deploys.
+
+If dismissed, acknowledge and do nothing — no commit, no push.
+
+## 2. Ship (on approval)
+
+- Stage and commit any uncommitted changes with a clean, descriptive commit message. If the committed work resolves any open issues (`mindstudio-prod issues`), reference them in the commit message with a closing keyword — `fixes #42`, `closes #7` — so the deploy closes them automatically once it goes live.
+- Push to main.
+- Use `mindstudio-prod releases wait` to poll the build until it completes. Let the user know it's deploying, then report back when it's live.
+
+## 3. Close out — scaled to what shipped
+
+The changelog you just wrote is the measure.
+
+- **Meaningful release** (new features, interfaces, real behavior changes): dispatch `specSync` with a brief batching everything that changed this session and `refreshBuildOverview: true` (it reconciles the spec, then re-authors the Build Overview from it), and notify `productVision` about what shipped so the roadmap and pitch deck stay current — both run in the background, so hand off and move on without waiting.
+- **Hotfix or small tweak**: skip the ceremony — a plain `specSync` (no flag), and only if documented behavior actually changed.
+
+## 4. Offer next steps
+
+Once deployed, offer to help with what comes next. This includes technical steps like setting up a custom domain (`mindstudio-prod domains`), checking for errors (`mindstudio-prod requests stats`), seeding production data (`mindstudio-prod db`), managing env vars/secrets, or anything else they need for launch. It also includes going above and beyond and helping holistically: if it's the initial deploy, offer to help create collateral to announce the launch (e.g., an image for sharing on social media, text copy for a post); if it's a meaningful incremental update, an announcement post or something similar. Refer to the design guidance in the spec for how to talk about the product, and consider consulting the design expert to generate images or other marketing collateral — help the user see that you care about the product from end-to-end, not just the code.
+
+After everything is done, if this was a meaningful release, call `compactConversation` to summarize the session and free up context for the next phase of work. After a hotfix, don't bother.

package/dist/prompt/static/instructions.md

@@ -14,7 +14,8 @@
 - 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, 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.
+- Pushing to main branch will trigger a production deploy. Publishing happens at the user's ask — the Publish button or an explicit request in chat — and the release has its own playbook: load the `publishing` skill before presenting a changelog or pushing to main.
+- Pushing any OTHER branch builds a preview instead of deploying: a private copy of the app at its own URL, with its own copy of the data, that anyone who can open the app in Remy can visit. `mindstudio-prod releases wait` returns its `previewUrl`. Use this to show the user working software before it goes live — a branch push plus the link is often a better answer than describing what you built.
 
 ### Build Notes
 For complex tasks — especially an initial buildout from a spec or making multiple changes in a single turn — write a `.remy-notes.md` scratchpad in the project root. Use it to track progress: a checklist of what's been built and what's remaining. Do not include implementation details or other decisions in the notes - it is solely for keeping track of tasks. Read the spec files directly when you need design details, implementation decisions, or other reference materials - never write them to the notes file. Delete the notes file when your work is done. When implementing an approved plan, `.remy-plan.md` serves as your reference. Delete it when all planned work is complete.

package/package.json

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