@mindstudio-ai/remy 0.1.303 → 0.1.304

package/dist/headless.d.ts

@@ -63,6 +63,20 @@ declare class HeadlessSession {
      * right state (the triggering turn's state, not a stale one).
      */
     private currentOnboardingState;
+    /**
+     * The in-flight turn's command, when that turn is part of a build pipeline
+     * (its action declares a `next`, or it is itself a chain step). Captured so a
+     * cancel can put the interrupted step back on the queue held, instead of
+     * leaving the pipeline to resume at the step *after* the one that was
+     * stopped — which would run finalize/polish over half-built code.
+     *
+     * Null for every other turn shape, which is what scopes the whole
+     * paused-pipeline affordance to chains: stopping a one-off automated action
+     * (approvePlan, publish, sync) leaves nothing behind.
+     */
+    private currentChainStep;
+    /** Monotonic suffix for synthesized chain requestIds — see nextChainRequestId. */
+    private chainRequestSeq;
     /**
      * Unified message queue. Holds pending work to deliver after the current
      * turn completes: chained automated actions, background sub-agent results,
@@ -134,6 +148,14 @@ declare class HeadlessSession {
      * filename de-dup set is per-call, so parallel calls race on names.
      */
     private persistEntryAttachments;
+    /**
+     * Stable id for a queued chain step, so the frontend can address one (to
+     * discard a paused pipeline) rather than waiting for drainQueueLoop to
+     * synthesize an id at dequeue. Deliberately not an `ac-` id — the frontend
+     * keys "system turn" off that prefix — and deliberately not a bare
+     * Date.now(), which collides for steps enqueued in the same millisecond.
+     */
+    private nextChainRequestId;
     /**
      * Run one turn for a single command (without acquiring the `running` lock).
      * Owns the per-command machinery: @@automated:: action resolution, plan-file
@@ -213,9 +235,9 @@ declare class HeadlessSession {
     /**
      * 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.
+     * `background` follow-ups that belonged to the turn, and HOLDS everything
+     * still queued — the `source: 'user'` items, which are independent user
+     * intent, plus the `source: 'chain'` steps of a build pipeline.
      *
      * Holding is the difference between Stop working and Stop looking broken.
      * These items used to drain immediately: `executeTurn` swallows the abort,
@@ -224,6 +246,13 @@ declare class HeadlessSession {
      * 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.
      *
+     * The chain steps used to be flushed with the background items, which threw
+     * away the rest of the build — including the step that finalizes it and
+     * unlocks the editor. They are now paused instead, and the interrupted step
+     * goes back at the head, so a Stop is a pause and the next send resumes the
+     * pipeline where it stopped. Holding only the remainder would resume one step
+     * PAST the interruption, polishing and finalizing half-built code.
+     *
      * 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
@@ -236,10 +265,15 @@ declare class HeadlessSession {
      */
     private handleCancel;
     /**
-     * Remove pending queued messages — all user messages, or one by id.
-     * Only `source: 'user'` items are removable; chained and background
-     * messages are part of a system chain and are never cancellable. Does
-     * not affect the in-flight turn (use `cancel` for that).
+     * Remove pending queued messages: all user messages (no id), or a single item
+     * by id. Does not affect the in-flight turn (use `cancel` for that).
+     *
+     * Held chain items — a paused pipeline — are removable only by explicit id.
+     * The id-less form is the queue card's "Clear" and the pre-destroy quiesce,
+     * neither of which should get to decide the pipeline's fate. A DELIVERABLE
+     * chain item is never removable: that's live pipeline work. (The step
+     * actually running isn't in the queue at all — drainQueueLoop takes it out
+     * before running it.)
      */
     private handleCancelQueued;
     private handleStdinLine;

package/dist/headless.js

@@ -9349,6 +9349,15 @@ var MessageQueue = class {
     this.items.push(item);
     this.onChange?.();
   }
+  /**
+   * Add an item at the head. Used to put an interrupted chain step back in
+   * front of the rest of its pipeline on cancel; `promoteToFront` can't serve
+   * that case, since it addresses an item already in the queue by requestId.
+   */
+  unshift(item) {
+    this.items.unshift(item);
+    this.onChange?.();
+  }
   /**
    * Index of the first deliverable item, or -1 when there is none.
    *
@@ -9417,25 +9426,6 @@ var MessageQueue = class {
     }
     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);
@@ -9480,6 +9470,38 @@ var MessageQueue = class {
     this.onChange?.();
     return item;
   }
+  /**
+   * Fold-in release: un-hold everything, then move items matching `defer` to
+   * the tail, relative order preserved. One onChange for the whole
+   * rearrangement, so no observer ever sees it half-applied.
+   *
+   * Callers push the new user message FIRST and call this second — "behind" is
+   * defined by the array at the moment this runs. Held user messages stay put
+   * so they still merge with that message into one mailbox batch; a paused
+   * pipeline goes to the back, so the person's words run before the build
+   * continues. `defer` is applied to every item, not just the newly-released
+   * ones, so a chain step that was already deliverable defers too.
+   */
+  releaseHeldDeferring(defer) {
+    const released = [];
+    for (const item of this.items) {
+      if (!item.held) {
+        continue;
+      }
+      delete item.held;
+      released.push(item);
+    }
+    const back = this.items.filter(defer);
+    const front = this.items.filter((item) => !defer(item));
+    const reordered = back.length > 0 && front.length > 0;
+    if (reordered) {
+      this.items = [...front, ...back];
+    }
+    if (released.length > 0 || reordered) {
+      this.onChange?.();
+    }
+    return released;
+  }
   /** Copy of current queue contents (for surfacing on events). */
   snapshot() {
     return [...this.items];
@@ -9529,6 +9551,20 @@ var HeadlessSession = class {
    * right state (the triggering turn's state, not a stale one).
    */
   currentOnboardingState;
+  /**
+   * The in-flight turn's command, when that turn is part of a build pipeline
+   * (its action declares a `next`, or it is itself a chain step). Captured so a
+   * cancel can put the interrupted step back on the queue held, instead of
+   * leaving the pipeline to resume at the step *after* the one that was
+   * stopped — which would run finalize/polish over half-built code.
+   *
+   * Null for every other turn shape, which is what scopes the whole
+   * paused-pipeline affordance to chains: stopping a one-off automated action
+   * (approvePlan, publish, sync) leaves nothing behind.
+   */
+  currentChainStep = null;
+  /** Monotonic suffix for synthesized chain requestIds — see nextChainRequestId. */
+  chainRequestSeq = 0;
   /**
    * Unified message queue. Holds pending work to deliver after the current
    * turn completes: chained automated actions, background sub-agent results,
@@ -10094,6 +10130,16 @@ var HeadlessSession = class {
       return void 0;
     }
   }
+  /**
+   * Stable id for a queued chain step, so the frontend can address one (to
+   * discard a paused pipeline) rather than waiting for drainQueueLoop to
+   * synthesize an id at dequeue. Deliberately not an `ac-` id — the frontend
+   * keys "system turn" off that prefix — and deliberately not a bare
+   * Date.now(), which collides for steps enqueued in the same millisecond.
+   */
+  nextChainRequestId() {
+    return `chain-${Date.now()}-${++this.chainRequestSeq}`;
+  }
   /**
    * Run one turn for a single command (without acquiring the `running` lock).
    * Owns the per-command machinery: @@automated:: action resolution, plan-file
@@ -10131,36 +10177,42 @@ var HeadlessSession = class {
     const onboardingState = parsed.onboardingState ?? "onboardingFinished";
     this.currentOnboardingState = onboardingState;
     const system = buildSystemPrompt(onboardingState);
+    this.currentChainStep = resolved && (resolved.next != null || fromChain) ? { text: rawText, onboardingState } : null;
     if (resolved?.next && !fromChain) {
       for (const step of getActionChain(resolved.next)) {
         this.queue.push({
           command: {
             action: "message",
             text: sentinel(step),
-            onboardingState
+            onboardingState,
+            requestId: this.nextChainRequestId()
           },
           source: "chain",
           enqueuedAt: Date.now()
         });
       }
     }
-    await this.executeTurn({
-      entries: [
-        {
-          text: userMessage,
-          attachments,
-          attachmentHeader,
-          hidden: isHidden || void 0,
-          requestId,
-          queued: queued || void 0
-        }
-      ],
-      requestId,
-      absorbedRids: [],
-      onboardingState,
-      system,
-      buildModel
-    });
+    try {
+      await this.executeTurn({
+        entries: [
+          {
+            text: userMessage,
+            attachments,
+            attachmentHeader,
+            hidden: isHidden || void 0,
+            requestId,
+            queued: queued || void 0
+          }
+        ],
+        requestId,
+        absorbedRids: [],
+        onboardingState,
+        system,
+        buildModel
+      });
+    } finally {
+      this.currentChainStep = null;
+    }
   }
   /**
    * Run a mailbox batch — contiguous queued user + background items — as one
@@ -10173,6 +10225,7 @@ var HeadlessSession = class {
    * with no side effects).
    */
   async runMergedTurn(batch) {
+    this.currentChainStep = null;
     const primaryRid = batch[0].command.requestId ?? (batch.every((b) => b.source === "background") ? `background-${Date.now()}` : `merged-${Date.now()}`);
     const absorbedRids = batch.slice(1).map((b) => b.command.requestId).filter((rid) => typeof rid === "string");
     const entryList = [];
@@ -10327,9 +10380,6 @@ var HeadlessSession = class {
   }
   async handleMessage(parsed, requestId) {
     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) {
@@ -10340,6 +10390,9 @@ var HeadlessSession = class {
         source: "user",
         enqueuedAt: Date.now()
       });
+      if (foldIn) {
+        this.queue.releaseHeldDeferring((item) => item.source === "chain");
+      }
       if (!this.running && !getInflightCompaction()) {
         this.kickDrain();
       }
@@ -10492,9 +10545,9 @@ var HeadlessSession = class {
   /**
    * 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.
+   * `background` follow-ups that belonged to the turn, and HOLDS everything
+   * still queued — the `source: 'user'` items, which are independent user
+   * intent, plus the `source: 'chain'` steps of a build pipeline.
    *
    * Holding is the difference between Stop working and Stop looking broken.
    * These items used to drain immediately: `executeTurn` swallows the abort,
@@ -10503,6 +10556,13 @@ var HeadlessSession = class {
    * 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.
    *
+   * The chain steps used to be flushed with the background items, which threw
+   * away the rest of the build — including the step that finalizes it and
+   * unlocks the editor. They are now paused instead, and the interrupted step
+   * goes back at the head, so a Stop is a pause and the next send resumes the
+   * pipeline where it stopped. Holding only the remainder would resume one step
+   * PAST the interruption, polishing and finalizing half-built code.
+   *
    * 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
@@ -10523,19 +10583,50 @@ var HeadlessSession = class {
       pending2.resolve(USER_CANCELLED_RESULT);
       this.pendingTools.delete(id);
     }
-    const flushed = this.queue.removeWhere((item) => item.source !== "user");
-    const held = this.queue.holdWhere((item) => item.source === "user");
-    return { flushed, held, cancelledCompaction };
+    const flushed = this.queue.removeWhere(
+      (item) => item.source === "background"
+    );
+    const step = this.currentChainStep;
+    if (step) {
+      this.queue.unshift({
+        command: {
+          action: "message",
+          text: step.text,
+          onboardingState: step.onboardingState,
+          // Fresh id: the original command's terminal has already gone out as
+          // cancelled, and one command gets exactly one `completed`.
+          requestId: this.nextChainRequestId()
+        },
+        source: "chain",
+        enqueuedAt: Date.now(),
+        held: true
+      });
+      this.currentChainStep = null;
+    }
+    const held = this.queue.holdWhere(
+      (item) => item.source === "user" || item.source === "chain"
+    );
+    return {
+      flushed,
+      held,
+      pausedPipeline: held.some((item) => item.source === "chain"),
+      cancelledCompaction
+    };
   }
   /**
-   * Remove pending queued messages — all user messages, or one by id.
-   * Only `source: 'user'` items are removable; chained and background
-   * messages are part of a system chain and are never cancellable. Does
-   * not affect the in-flight turn (use `cancel` for that).
+   * Remove pending queued messages: all user messages (no id), or a single item
+   * by id. Does not affect the in-flight turn (use `cancel` for that).
+   *
+   * Held chain items — a paused pipeline — are removable only by explicit id.
+   * The id-less form is the queue card's "Clear" and the pre-destroy quiesce,
+   * neither of which should get to decide the pipeline's fate. A DELIVERABLE
+   * chain item is never removable: that's live pipeline work. (The step
+   * actually running isn't in the queue at all — drainQueueLoop takes it out
+   * before running it.)
    */
   handleCancelQueued(id) {
     return this.queue.removeWhere(
-      (item) => item.source === "user" && (id === void 0 || item.command.requestId === id)
+      (item) => id === void 0 ? item.source === "user" : item.command.requestId === id && (item.source === "user" || item.source === "chain" && !!item.held)
     );
   }
   //////////////////////////////////////////////////////////////////////////////
@@ -10634,13 +10725,14 @@ var HeadlessSession = class {
       return;
     }
     if (action === "cancel") {
-      const { flushed, held, cancelledCompaction } = this.handleCancel();
+      const { flushed, held, pausedPipeline, cancelledCompaction } = this.handleCancel();
       this.emit(
         "completed",
         {
           success: true,
           ...flushed.length > 0 && { cancelledMessages: flushed },
           ...held.length > 0 && { heldMessages: held },
+          ...pausedPipeline && { pausedPipeline: true },
           ...cancelledCompaction && { cancelledCompaction: true }
         },
         requestId

package/dist/index.js

@@ -10311,6 +10311,15 @@ var init_messageQueue = __esm({
         this.items.push(item);
         this.onChange?.();
       }
+      /**
+       * Add an item at the head. Used to put an interrupted chain step back in
+       * front of the rest of its pipeline on cancel; `promoteToFront` can't serve
+       * that case, since it addresses an item already in the queue by requestId.
+       */
+      unshift(item) {
+        this.items.unshift(item);
+        this.onChange?.();
+      }
       /**
        * Index of the first deliverable item, or -1 when there is none.
        *
@@ -10379,25 +10388,6 @@ var init_messageQueue = __esm({
         }
         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);
@@ -10442,6 +10432,38 @@ var init_messageQueue = __esm({
         this.onChange?.();
         return item;
       }
+      /**
+       * Fold-in release: un-hold everything, then move items matching `defer` to
+       * the tail, relative order preserved. One onChange for the whole
+       * rearrangement, so no observer ever sees it half-applied.
+       *
+       * Callers push the new user message FIRST and call this second — "behind" is
+       * defined by the array at the moment this runs. Held user messages stay put
+       * so they still merge with that message into one mailbox batch; a paused
+       * pipeline goes to the back, so the person's words run before the build
+       * continues. `defer` is applied to every item, not just the newly-released
+       * ones, so a chain step that was already deliverable defers too.
+       */
+      releaseHeldDeferring(defer) {
+        const released = [];
+        for (const item of this.items) {
+          if (!item.held) {
+            continue;
+          }
+          delete item.held;
+          released.push(item);
+        }
+        const back = this.items.filter(defer);
+        const front = this.items.filter((item) => !defer(item));
+        const reordered = back.length > 0 && front.length > 0;
+        if (reordered) {
+          this.items = [...front, ...back];
+        }
+        if (released.length > 0 || reordered) {
+          this.onChange?.();
+        }
+        return released;
+      }
       /** Copy of current queue contents (for surfacing on events). */
       snapshot() {
         return [...this.items];
@@ -10519,6 +10541,20 @@ var init_headless = __esm({
        * right state (the triggering turn's state, not a stale one).
        */
       currentOnboardingState;
+      /**
+       * The in-flight turn's command, when that turn is part of a build pipeline
+       * (its action declares a `next`, or it is itself a chain step). Captured so a
+       * cancel can put the interrupted step back on the queue held, instead of
+       * leaving the pipeline to resume at the step *after* the one that was
+       * stopped — which would run finalize/polish over half-built code.
+       *
+       * Null for every other turn shape, which is what scopes the whole
+       * paused-pipeline affordance to chains: stopping a one-off automated action
+       * (approvePlan, publish, sync) leaves nothing behind.
+       */
+      currentChainStep = null;
+      /** Monotonic suffix for synthesized chain requestIds — see nextChainRequestId. */
+      chainRequestSeq = 0;
       /**
        * Unified message queue. Holds pending work to deliver after the current
        * turn completes: chained automated actions, background sub-agent results,
@@ -11084,6 +11120,16 @@ var init_headless = __esm({
           return void 0;
         }
       }
+      /**
+       * Stable id for a queued chain step, so the frontend can address one (to
+       * discard a paused pipeline) rather than waiting for drainQueueLoop to
+       * synthesize an id at dequeue. Deliberately not an `ac-` id — the frontend
+       * keys "system turn" off that prefix — and deliberately not a bare
+       * Date.now(), which collides for steps enqueued in the same millisecond.
+       */
+      nextChainRequestId() {
+        return `chain-${Date.now()}-${++this.chainRequestSeq}`;
+      }
       /**
        * Run one turn for a single command (without acquiring the `running` lock).
        * Owns the per-command machinery: @@automated:: action resolution, plan-file
@@ -11121,36 +11167,42 @@ var init_headless = __esm({
         const onboardingState = parsed.onboardingState ?? "onboardingFinished";
         this.currentOnboardingState = onboardingState;
         const system = buildSystemPrompt(onboardingState);
+        this.currentChainStep = resolved && (resolved.next != null || fromChain) ? { text: rawText, onboardingState } : null;
         if (resolved?.next && !fromChain) {
           for (const step of getActionChain(resolved.next)) {
             this.queue.push({
               command: {
                 action: "message",
                 text: sentinel(step),
-                onboardingState
+                onboardingState,
+                requestId: this.nextChainRequestId()
               },
               source: "chain",
               enqueuedAt: Date.now()
             });
           }
         }
-        await this.executeTurn({
-          entries: [
-            {
-              text: userMessage,
-              attachments,
-              attachmentHeader,
-              hidden: isHidden || void 0,
-              requestId,
-              queued: queued || void 0
-            }
-          ],
-          requestId,
-          absorbedRids: [],
-          onboardingState,
-          system,
-          buildModel
-        });
+        try {
+          await this.executeTurn({
+            entries: [
+              {
+                text: userMessage,
+                attachments,
+                attachmentHeader,
+                hidden: isHidden || void 0,
+                requestId,
+                queued: queued || void 0
+              }
+            ],
+            requestId,
+            absorbedRids: [],
+            onboardingState,
+            system,
+            buildModel
+          });
+        } finally {
+          this.currentChainStep = null;
+        }
       }
       /**
        * Run a mailbox batch — contiguous queued user + background items — as one
@@ -11163,6 +11215,7 @@ var init_headless = __esm({
        * with no side effects).
        */
       async runMergedTurn(batch) {
+        this.currentChainStep = null;
         const primaryRid = batch[0].command.requestId ?? (batch.every((b) => b.source === "background") ? `background-${Date.now()}` : `merged-${Date.now()}`);
         const absorbedRids = batch.slice(1).map((b) => b.command.requestId).filter((rid) => typeof rid === "string");
         const entryList = [];
@@ -11317,9 +11370,6 @@ var init_headless = __esm({
       }
       async handleMessage(parsed, requestId) {
         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) {
@@ -11330,6 +11380,9 @@ var init_headless = __esm({
             source: "user",
             enqueuedAt: Date.now()
           });
+          if (foldIn) {
+            this.queue.releaseHeldDeferring((item) => item.source === "chain");
+          }
           if (!this.running && !getInflightCompaction()) {
             this.kickDrain();
           }
@@ -11482,9 +11535,9 @@ var init_headless = __esm({
       /**
        * 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.
+       * `background` follow-ups that belonged to the turn, and HOLDS everything
+       * still queued — the `source: 'user'` items, which are independent user
+       * intent, plus the `source: 'chain'` steps of a build pipeline.
        *
        * Holding is the difference between Stop working and Stop looking broken.
        * These items used to drain immediately: `executeTurn` swallows the abort,
@@ -11493,6 +11546,13 @@ var init_headless = __esm({
        * 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.
        *
+       * The chain steps used to be flushed with the background items, which threw
+       * away the rest of the build — including the step that finalizes it and
+       * unlocks the editor. They are now paused instead, and the interrupted step
+       * goes back at the head, so a Stop is a pause and the next send resumes the
+       * pipeline where it stopped. Holding only the remainder would resume one step
+       * PAST the interruption, polishing and finalizing half-built code.
+       *
        * 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
@@ -11513,19 +11573,50 @@ var init_headless = __esm({
           pending2.resolve(USER_CANCELLED_RESULT);
           this.pendingTools.delete(id);
         }
-        const flushed = this.queue.removeWhere((item) => item.source !== "user");
-        const held = this.queue.holdWhere((item) => item.source === "user");
-        return { flushed, held, cancelledCompaction };
+        const flushed = this.queue.removeWhere(
+          (item) => item.source === "background"
+        );
+        const step = this.currentChainStep;
+        if (step) {
+          this.queue.unshift({
+            command: {
+              action: "message",
+              text: step.text,
+              onboardingState: step.onboardingState,
+              // Fresh id: the original command's terminal has already gone out as
+              // cancelled, and one command gets exactly one `completed`.
+              requestId: this.nextChainRequestId()
+            },
+            source: "chain",
+            enqueuedAt: Date.now(),
+            held: true
+          });
+          this.currentChainStep = null;
+        }
+        const held = this.queue.holdWhere(
+          (item) => item.source === "user" || item.source === "chain"
+        );
+        return {
+          flushed,
+          held,
+          pausedPipeline: held.some((item) => item.source === "chain"),
+          cancelledCompaction
+        };
       }
       /**
-       * Remove pending queued messages — all user messages, or one by id.
-       * Only `source: 'user'` items are removable; chained and background
-       * messages are part of a system chain and are never cancellable. Does
-       * not affect the in-flight turn (use `cancel` for that).
+       * Remove pending queued messages: all user messages (no id), or a single item
+       * by id. Does not affect the in-flight turn (use `cancel` for that).
+       *
+       * Held chain items — a paused pipeline — are removable only by explicit id.
+       * The id-less form is the queue card's "Clear" and the pre-destroy quiesce,
+       * neither of which should get to decide the pipeline's fate. A DELIVERABLE
+       * chain item is never removable: that's live pipeline work. (The step
+       * actually running isn't in the queue at all — drainQueueLoop takes it out
+       * before running it.)
        */
       handleCancelQueued(id) {
         return this.queue.removeWhere(
-          (item) => item.source === "user" && (id === void 0 || item.command.requestId === id)
+          (item) => id === void 0 ? item.source === "user" : item.command.requestId === id && (item.source === "user" || item.source === "chain" && !!item.held)
         );
       }
       //////////////////////////////////////////////////////////////////////////////
@@ -11624,13 +11715,14 @@ var init_headless = __esm({
           return;
         }
         if (action === "cancel") {
-          const { flushed, held, cancelledCompaction } = this.handleCancel();
+          const { flushed, held, pausedPipeline, cancelledCompaction } = this.handleCancel();
           this.emit(
             "completed",
             {
               success: true,
               ...flushed.length > 0 && { cancelledMessages: flushed },
               ...held.length > 0 && { heldMessages: held },
+              ...pausedPipeline && { pausedPipeline: true },
               ...cancelledCompaction && { cancelledCompaction: true }
             },
             requestId

package/dist/prompt/compiled/interfaces.md

@@ -45,6 +45,8 @@ All fields are nested under the `"web"` key.
 | `defaultPreviewMode` | `"desktop"` \| `"mobile"` | `"desktop"` | Default preview viewport in the editor. Set to `"mobile"` for mobile-first apps. |
 | `prerender` | `object` | — | Opt into prerendering the listed routes/patterns for crawlers/unfurlers. See "Prerendering" below. |
 | `mounts` | `array` | — | Serve other same-workspace apps under path prefixes of this app's hosts. See "Mounting other apps" below. |
+| `redirects` | `array` | — | Path-level redirects. See "Redirects" below. |
+| `trailingSlash` | `"strip"` \| `"append"` | — | Enforce a canonical trailing-slash form with a 308. Off by default. |
 
 ### Frontend SDK
 
@@ -136,7 +138,7 @@ Opt in per route in `web.json`:
 { "web": { "prerender": { "paths": ["/u/*", "/blog/*"] } } }
 ```
 
-`prerender` is an object with a single field, `paths`: an array of route globs (`*` = one segment, `**` = any). Only listed routes prerender.
+`prerender` is an object with a single field, `paths`: an array of route globs (`*` = one segment, `**` = any). Only listed routes prerender, and only routes — a path with a file extension (`/robots.txt`, `/sitemap.xml`) never prerenders, even under `/**`.
 
 The opt-in alone is not enough. For every route in `prerender.paths`, the SPA must set `document.documentElement.setAttribute('data-prerender-ready', 'true')` once the head is written and the route has resolved — this is required, not optional. The renderer waits for this marker, so a prerendered route that never sets it times out. Set it even on routes that render synchronously, as soon as they're ready.
 
@@ -149,9 +151,28 @@ await prerender.invalidate(['/u/abc']); // omit arg to purge all
 
 `remy-admin prerender` can help you verify/manage snapshots during development.
 
+### Redirects
+
+Declare moved URLs in `web.json` — never ship a component that redirects client-side, since that resolves after JS loads and crawlers won't follow it:
+
+```json
+{ "web": { "trailingSlash": "strip", "redirects": [
+  { "source": "/old-blog/*slug", "destination": "/blog/*slug", "permanent": true },
+  { "source": "/launch", "destination": "https://example.com/launch", "statusCode": 302 }
+] } }
+```
+
+`source` is a `/`-prefixed pattern; `destination` is a path or absolute http(s) URL. `permanent` (true → 308, false → 307) is required unless you set an explicit `statusCode` of 301/302/307/308; you can't set both. First match wins, and the request's query carries over unless the destination has its own.
+
+**Pattern syntax is path-to-regexp v8, NOT the Next.js dialect** — the one thing to get right here. One segment is `:name`; a multi-segment wildcard is `*name` (Next's `:name*`); optional segments use braces (`/users{/:id}`); inline regex (`:id(\\d+)`) is unsupported. The v6/Next forms fail the build with the correct syntax in the error.
+
+`trailingSlash` picks the canonical form (`"strip"`: `/about/` → `/about`; `"append"`: the reverse, skipping the root and paths with file extensions). Off by default. Write `source` patterns without trailing slashes either way — normalization and matching resolve in one hop. Sources under `/_/` are rejected, as are self-referential and two-rule loops. A redirecting path is never prerendered, so don't list one in `prerender.paths`.
+
 ### Mounting other apps
 
-Rare: `mounts` serves another same-workspace app under a path prefix of this app's hosts — `{ "web": { "mounts": [{ "path": "/docs", "app": "docs-site" }] } }` (`app` = the target's `custom_subdomain` or appId). The child is served first-class (its own bundle, session, backend) and needs no mount-specific config; the two serving conventions above are what make an app mountable.
+Rare: `mounts` serves another same-workspace app under a path prefix of this app's hosts — `{ "web": { "mounts": [{ "path": "/docs", "app": "docs-site" }] } }` (`app` = the target's `custom_subdomain` or appId). The child is served first-class (its own bundle, session, backend, prerendering) and needs no mount-specific config; the two serving conventions above are what make an app mountable.
+
+Under a mount the child's own `web.json` governs its SEO and routing: its `prerender.paths` gates its mounted pages, its `prerender.invalidate` purges them, its `redirects`/`trailingSlash` apply within the prefix (written against its own paths, with the prefix added back to relative destinations), and its `sitemap.xml` is served with URLs rewritten to the mount and advertised in the parent's `robots.txt`. The child's `robots.txt` *rules* don't carry over (the build log lists them prefixed for the parent to adopt), and canonicals must be written from the page's own location — a hardcoded absolute canonical points crawlers back at the child's host and undoes the mount.
 
 ## API Interface
 

package/dist/prompt/skills/publishing.md

@@ -18,6 +18,7 @@ If dismissed, acknowledge and do nothing — no commit, no push.
 
 ## 2. Ship (on approval)
 
+- On a meaningful release, glance at dependencies before committing — `npm outdated` in the methods package and in each interface's web directory. The first-party packages (`@mindstudio-ai/agent`, `@mindstudio-ai/interface`, `@madewithremy/admin`) are ours and versioned additively: a bump brings new capabilities and bug fixes, not a migration. Bring those current without asking, typecheck, and mention it in plain language when you report the deploy; if a bump does need a small code change, just make it. Third-party packages are the user's time to spend, so flag anything meaningfully behind and let them decide. Skip all of this on a hotfix — a quick fix going out doesn't need a dependency pass.
 - Stage and commit any uncommitted changes with a clean, descriptive commit message. If the committed work resolves any open issues (`remy-admin 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 `remy-admin releases wait` to poll the build until it completes. Let the user know it's deploying, then report back when it's live.

package/dist/subagents/codeSanityCheck/prompt.md

@@ -39,7 +39,7 @@ These are things we already know about and have decided to accept:
   - use [wouter](https://github.com/molefrog/wouter) for React routing instead of reaching for react-router
   - uploading user files should always happen via `platform.uploadFile()` from `@mindstudio-ai/interface` — not custom S3 code, not FormData to a method endpoint
   - for build-time prerendering of purely static sites (marketing pages with no dynamic content — distinct from the platform's crawler prerendering, below), roll your own with a post-build `renderToString` script — do not use `vite-prerender-plugin` (it bundles the prerender script as a client chunk, adding ~800KB to the user-facing bundle with no way to prevent it)
-  - **Prerendering for crawlers/unfurlers is a platform feature — don't design around it.** For SEO / link-unfurl / AI-crawler visibility on a non-static SPA, the platform already handles it: routes opt in via `web.json` (`{ "web": { "prerender": { "paths": ["/blog/*"] } } }`), the SPA signals readiness by setting `data-prerender-ready` on the html element, deploys invalidate the snapshot cache automatically, and content that changes outside deploys is invalidated at runtime with `await prerender.invalidate([...])` from `@mindstudio-ai/agent` (called from the mutating method). It serves cached headless snapshots of the live SPA to bots — it is NOT build-time rendering. Do not recommend post-build render scripts, rebuild-on-content-change, or third-party prerender services for this. The developer's main context carries the full interfaces reference with exact semantics — tell them to consult it rather than improvising.
+  - **Prerendering for crawlers/unfurlers is a platform feature — don't design around it.** For SEO / link-unfurl / AI-crawler visibility on a non-static SPA, the platform already handles it: routes opt in via `web.json` (`{ "web": { "prerender": { "paths": ["/blog/*"] } } }`), the SPA signals readiness by setting `data-prerender-ready` on the html element, deploys invalidate the snapshot cache automatically, and content that changes outside deploys is invalidated at runtime with `await prerender.invalidate([...])` from `@mindstudio-ai/agent` (called from the mutating method). It serves cached headless snapshots of the live SPA to bots — it is NOT build-time rendering. Do not recommend post-build render scripts, rebuild-on-content-change, or third-party prerender services for this. An app mounted under another app's path prefix keeps its own `prerender.paths` and its own `prerender.invalidate` — don't recommend moving prerender config to the parent, and don't hand-roll sitemap/robots rewriting for a mount (the platform rewrites the mounted sitemap and advertises it in the parent's robots.txt). The developer's main context carries the full interfaces reference with exact semantics — tell them to consult it rather than improvising.
 
 ### Common pitfalls (always flag these)
 

package/package.json

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