@songsid/agend 2.1.4-beta.16 → 2.1.4-beta.18

package/dist/daemon.js

@@ -775,6 +775,12 @@ export class Daemon extends EventEmitter {
      *  and ⏳/👀/✅ reactions live here). It does NOT cover the other writers that
      *  reach the pane — {@link paneWriteLock} does. */
     pasteLock = Promise.resolve();
+    /**
+     * Fleet cancellation epoch. Queue entries retain the epoch they arrived with;
+     * advancing it invalidates only work received before the cancel, never a new
+     * user message which arrives immediately afterwards.
+     */
+    deliveryEpoch = 0;
     /** Mutual exclusion for *every* write into the pane, whichever subsystem it
      *  comes from. See PaneWriteLock for why interleaving is destructive. */
     paneWriteLock = new PaneWriteLock();
@@ -1000,36 +1006,33 @@ export class Daemon extends EventEmitter {
                 // Fleet manager routed a message to us (topic mode)
                 const meta = msg.meta;
                 const targetSession = msg.targetSession;
+                const deliveryEpoch = this.captureDeliveryEpoch(msg.delivery_epoch);
                 void this.wake().then(() => {
-                    this.pushChannelMessage(msg.content, meta, targetSession);
+                    this.pushChannelMessage(msg.content, meta, targetSession, deliveryEpoch);
                 }).catch(err => {
                     this.logger.error({ err: err.message }, "Wake failed for inbound delivery");
                 });
             }
             else if (msg.type === "raw_paste") {
                 // Paste raw text directly to CLI without [user:] wrapping.
-                if (this.tmux) {
-                    const rawText = msg.content;
-                    this.pasteLock = this.pasteLock.then(async () => {
-                        await this.wake();
-                        await this.deliverMessage(rawText);
-                        this.logger.debug({ text: rawText.slice(0, 100) }, "Raw paste delivered");
-                    }).catch(err => {
-                        this.logger.warn({ err: err.message }, "raw_paste delivery error");
-                    });
-                }
+                this.queueRawPaste(msg.content, this.captureDeliveryEpoch(msg.delivery_epoch));
             }
             else if (msg.type === "config_update") {
                 this.applyConfigUpdate(msg.config);
             }
             else if (msg.type === "steer") {
                 const meta = (msg.meta ?? {});
-                this.steerMessage(msg.content, meta);
+                this.steerMessage(msg.content, meta, this.captureDeliveryEpoch(msg.delivery_epoch));
+            }
+            else if (msg.type === "btw") {
+                const meta = (msg.meta ?? {});
+                this.btwMessage(msg.content, meta, this.captureDeliveryEpoch(msg.delivery_epoch));
             }
             else if (msg.type === "fleet_schedule_trigger") {
                 const payload = msg.payload;
                 const meta = msg.meta;
-                void this.wake().then(() => this.pushChannelMessage(payload.message, meta)).catch(err => {
+                const deliveryEpoch = this.captureDeliveryEpoch(msg.delivery_epoch);
+                void this.wake().then(() => this.pushChannelMessage(payload.message, meta, undefined, deliveryEpoch)).catch(err => {
                     this.logger.error({ err: err.message }, "Wake failed for scheduled delivery");
                 });
             }
@@ -1871,6 +1874,46 @@ export class Daemon extends EventEmitter {
         const cancelKey = this.backend?.getCancelKey() ?? "Escape";
         await this.tmux?.sendSpecialKey(cancelKey);
     }
+    /**
+     * Drop every not-yet-started pane delivery which predates a user cancel.
+     * Promise chains cannot be removed, so entries become generation-checked
+     * no-ops. An entry already past its check is allowed to finish its current PTY
+     * transaction; the interrupt key still cancels the CLI generation.
+     */
+    clearPendingDeliveries(fleetEpoch) {
+        this.deliveryEpoch = fleetEpoch === undefined
+            ? this.deliveryEpoch + 1
+            : Math.max(this.deliveryEpoch, fleetEpoch);
+        this.logger.info({ deliveryEpoch: this.deliveryEpoch }, "Pending delivery queue cleared by user cancel");
+    }
+    captureDeliveryEpoch(value) {
+        const epoch = typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+            ? value
+            : this.deliveryEpoch;
+        if (epoch > this.deliveryEpoch)
+            this.deliveryEpoch = epoch;
+        return epoch;
+    }
+    isDeliveryEpochCurrent(epoch) {
+        return epoch === this.deliveryEpoch;
+    }
+    queueRawPaste(rawText, deliveryEpoch = this.deliveryEpoch) {
+        if (!this.tmux || !this.isDeliveryEpochCurrent(deliveryEpoch))
+            return;
+        this.pasteLock = this.pasteLock.then(async () => {
+            if (!this.isDeliveryEpochCurrent(deliveryEpoch)) {
+                this.logger.info("Pending raw delivery dropped by user cancel");
+                return;
+            }
+            await this.wake();
+            if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+                return;
+            await this.deliverMessage(rawText, undefined, { deliveryEpoch });
+            this.logger.debug({ text: rawText.slice(0, 100) }, "Raw paste delivered");
+        }).catch(err => {
+            this.logger.warn({ err: err.message }, "raw_paste delivery error");
+        });
+    }
     /** Send the backend-specific graceful quit command/key sequence. */
     async sendQuitSequence() {
         if (!this.tmux || !this.backend)
@@ -2785,7 +2828,9 @@ export class Daemon extends EventEmitter {
      * The steered text goes through formatInboundMessage so the agent sees a
      * normal inbound message, with a steering notice prepended for context.
      */
-    steerMessage(content, meta) {
+    steerMessage(content, meta, deliveryEpoch = this.deliveryEpoch) {
+        if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+            return;
         this.updateLastChat(meta.chat_id, meta.thread_id, meta.adapter_id);
         this.pendingWork.recordInbound();
         this.recordRecentUserMessage(content, meta);
@@ -2797,20 +2842,60 @@ export class Daemon extends EventEmitter {
             ? { chatId: meta.thread_id || chatId, messageId }
             : undefined;
         this.steerLock = this.steerLock.then(async () => {
+            if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+                return;
             await this.wake();
-            if (await this.deliverMessage(formatted, status, { steer: true })) {
+            if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+                return;
+            if (await this.deliverMessage(formatted, status, { steer: true, deliveryEpoch })) {
                 this.markTurnStarted(meta, formatted);
             }
         }).catch(err => {
             this.logger.warn({ err: err.message }, "steer delivery error");
         });
     }
+    /**
+     * /btw: submit a separately-labelled side question immediately while asking
+     * the agent not to change the active task. Claude's native `/btw` opens a
+     * branchAndResume panel whose answer never reaches the channel or transcript,
+     * so channel delivery intentionally uses a normal wrapped inbound instead.
+     */
+    btwMessage(content, meta, deliveryEpoch = this.deliveryEpoch) {
+        if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+            return;
+        this.updateLastChat(meta.chat_id, meta.thread_id, meta.adapter_id);
+        this.pendingWork.recordInbound();
+        this.recordRecentUserMessage(content, meta);
+        const formatted = "[BTW — side question from the user. Answer it separately without changing or interrupting the CURRENT work.]\n"
+            + this.formatInboundMessage(content, meta);
+        const chatId = meta.chat_id;
+        const messageId = meta.message_id;
+        const status = (chatId && messageId)
+            ? { chatId: meta.thread_id || chatId, messageId }
+            : undefined;
+        this.steerLock = this.steerLock.then(async () => {
+            if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+                return;
+            await this.wake();
+            if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+                return;
+            if (await this.deliverMessage(formatted, status, { steer: true, deliveryEpoch })) {
+                this.markTurnStarted(meta, formatted);
+            }
+        }).catch(err => {
+            this.logger.warn({ err: err.message }, "btw delivery error");
+        });
+    }
     /**
      * Push an inbound channel message to a specific MCP session.
      * If targetSession is provided, only send to the matching socket.
      * Otherwise send to the instance's own session (this.name).
      */
-    pushChannelMessage(content, meta, _targetSession) {
+    pushChannelMessage(content, meta, _targetSession, deliveryEpoch = this.deliveryEpoch) {
+        if (!this.isDeliveryEpochCurrent(deliveryEpoch)) {
+            this.logger.info("Pending channel delivery dropped by user cancel");
+            return;
+        }
         if (!this.tmux) {
             this.logger.warn("Cannot push channel message: tmux not running");
             return;
@@ -2844,7 +2929,9 @@ export class Daemon extends EventEmitter {
             const rawText = content.slice(5);
             this.logger.info({ user }, "Raw paste from topic mode user");
             this.pasteLock = this.pasteLock.then(async () => {
-                if (await this.deliverMessage(rawText))
+                if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+                    return;
+                if (await this.deliverMessage(rawText, undefined, { deliveryEpoch }))
                     this.markTurnStarted(meta, rawText);
             }).catch(err => {
                 this.logger.warn({ err: err.message }, "pasteLock raw delivery error");
@@ -2854,8 +2941,7 @@ export class Daemon extends EventEmitter {
         const formatted = this.formatInboundMessage(content, meta);
         // Serialize deliveries: each message waits for the previous to complete,
         // and each waits for the CLI to be idle before pasting. Messages are never
-        // dropped for age — a long-busy CLI just queues them until it frees up
-        // (the user can press Cancel to interrupt and let the queue drain sooner).
+        // dropped for age — only an explicit user Cancel invalidates queued work.
         const chatId = meta.chat_id;
         const messageId = meta.message_id;
         const wasQueued = this.pasteQueueDepth > 0;
@@ -2868,12 +2954,20 @@ export class Daemon extends EventEmitter {
         }
         this.pasteLock = this.pasteLock.then(async () => {
             try {
+                if (!this.isDeliveryEpochCurrent(deliveryEpoch)) {
+                    this.logger.info("Pending channel delivery dropped by user cancel");
+                    return;
+                }
                 if (this.config.pre_task_command) {
-                    await this.deliverMessage(this.config.pre_task_command);
+                    await this.deliverMessage(this.config.pre_task_command, undefined, { deliveryEpoch });
+                    if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+                        return;
                 }
                 if (this.pendingInstructionsNotice) {
                     this.pendingInstructionsNotice = false;
-                    await this.deliverMessage(buildInstructionReloadNotice(this.backend?.binaryName ?? "unknown", this.name, this.instanceDir));
+                    await this.deliverMessage(buildInstructionReloadNotice(this.backend?.binaryName ?? "unknown", this.name, this.instanceDir), undefined, { deliveryEpoch });
+                    if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+                        return;
                 }
                 const status = (chatId && messageId)
                     ? { chatId: meta.thread_id || chatId, messageId }
@@ -2881,7 +2975,7 @@ export class Daemon extends EventEmitter {
                 // A fresh delivery begins a fresh turn — its bubble must not inherit
                 // the previous turn's tool list.
                 this.resetToolProgress();
-                if (await this.deliverMessage(formatted, status))
+                if (await this.deliverMessage(formatted, status, { deliveryEpoch }))
                     this.markTurnStarted(meta, formatted);
             }
             finally {
@@ -2909,6 +3003,10 @@ export class Daemon extends EventEmitter {
      * serial in both cases so separate PTY writes can never overlap.
      */
     async deliverMessage(formatted, status, opts) {
+        const cancelled = () => opts?.deliveryEpoch !== undefined
+            && !this.isDeliveryEpochCurrent(opts.deliveryEpoch);
+        if (cancelled())
+            return false;
         // Sanitize unclosed code fences — they cause CLI to wait for closure on Enter
         const fenceCount = (formatted.match(/```/g) || []).length;
         if (fenceCount % 2 !== 0) {
@@ -2917,6 +3015,8 @@ export class Daemon extends EventEmitter {
         }
         // Before anything reads the window id: a spawn in progress is about to change it.
         await this.waitForSpawnToSettle();
+        if (cancelled())
+            return false;
         let windowId = this.getWindowId();
         const supportsQueuedInput = this.backend?.supportsQueuedInput?.() === true;
         let handingOffToNativeQueue = false;
@@ -2938,6 +3038,8 @@ export class Daemon extends EventEmitter {
             else {
                 this.logger.debug("CLI busy — queuing message until idle");
                 const becameIdle = await this.controlClient.waitUntilIdle(windowId);
+                if (cancelled())
+                    return false;
                 if (!becameIdle) {
                     // The pane never freed up. Report the failure instead of pasting into a
                     // wedged CLI (where the text would sit unsubmitted and the next message
@@ -2953,7 +3055,11 @@ export class Daemon extends EventEmitter {
         // held under the pane lock — holding it across the idle wait (up to 30 min)
         // would starve the runtime-dialog dismisser, which is often the very thing
         // that would let the pane go idle again.
-        return this.paneWriteLock.run(() => this.writeMessageToPane(formatted, windowId, handingOffToNativeQueue, status));
+        return this.paneWriteLock.run(async () => {
+            if (cancelled())
+                return false;
+            return this.writeMessageToPane(formatted, windowId, handingOffToNativeQueue, status);
+        });
     }
     /**
      * The write half of a delivery: paste → Enter → confirm, with retries.