@songsid/agend 2.1.5 → 2.1.6-beta.1

package/dist/fleet-manager.d.ts

@@ -181,6 +181,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private instanceIdleWaiters;
     private lastInboundUser;
     private cancelButtons;
+    /** Latest publication generation per instance. Late results from older
+     * generations are retired without touching the current button. */
+    private cancelButtonPublications;
+    private nextCancelButtonPublicationGeneration;
     /** Pending idle-edge retirement, one timer per instance. */
     private cancelButtonIdleRetireTimers;
     /** Duplicate-reply suppression across both the MCP and HTTP reply paths. */
@@ -1056,6 +1060,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private handleCancelClick;
     private hasCancelButton;
+    private beginCancelButtonPublication;
+    /** Remember a clear/cancel/idle decision that arrived before notifyAlert
+     * returned a message id. `expected` fences an idle timer to its generation. */
+    private markCancelButtonPublicationForRetirement;
     sendCancelButton(instanceName: string, correlationId?: string, preserveProgress?: boolean): Promise<void>;
     /**
      * The cancel button's text for a given elapsed time.

package/dist/fleet-manager.js

@@ -383,6 +383,10 @@ export class FleetManager {
     // reply, on cancel, or when a newer button supersedes it for the same
     // instance. Per-button tracking means a failed delete never strands a button.
     cancelButtons = new Map();
+    /** Latest publication generation per instance. Late results from older
+     * generations are retired without touching the current button. */
+    cancelButtonPublications = new Map();
+    nextCancelButtonPublicationGeneration = 0;
     /** Pending idle-edge retirement, one timer per instance. */
     cancelButtonIdleRetireTimers = new Map();
     /** Duplicate-reply suppression across both the MCP and HTTP reply paths. */
@@ -1181,12 +1185,17 @@ export class FleetManager {
     }
     scheduleIdleButtonRetirement(name) {
         this.cancelIdleButtonRetirement(name);
+        // Bind this edge to the publication that was current when idle was
+        // observed. A later inbound may start a new generation before this timer
+        // fires; the old edge must not mark that newer button for retirement.
+        const publication = this.cancelButtonPublications.get(name);
         const timer = setTimeout(() => {
             // Ignore a superseded timer even if it was already queued to run.
             if (this.cancelButtonIdleRetireTimers.get(name) !== timer)
                 return;
             this.cancelButtonIdleRetireTimers.delete(name);
             if (this.getInstanceExecutionState(name) === "idle") {
+                this.markCancelButtonPublicationForRetirement(name, publication);
                 this.retireInstanceButtons(name);
             }
         }, CANCEL_BTN_IDLE_RETIRE_GRACE_MS);
@@ -7098,6 +7107,30 @@ export class FleetManager {
         }
         return false;
     }
+    beginCancelButtonPublication(instanceName, correlationId) {
+        // A new handoff supersedes any idle timer left by the previous turn. If the
+        // instance is still idle after this publication, the post-await level check
+        // below starts a fresh grace period for this generation.
+        this.cancelIdleButtonRetirement(instanceName);
+        const publication = {
+            generation: ++this.nextCancelButtonPublicationGeneration,
+            correlationId,
+            inFlight: true,
+            retirePending: false,
+        };
+        this.cancelButtonPublications.set(instanceName, publication);
+        return publication;
+    }
+    /** Remember a clear/cancel/idle decision that arrived before notifyAlert
+     * returned a message id. `expected` fences an idle timer to its generation. */
+    markCancelButtonPublicationForRetirement(instanceName, expected) {
+        const publication = this.cancelButtonPublications.get(instanceName);
+        if (!publication?.inFlight)
+            return;
+        if (expected && publication !== expected)
+            return;
+        publication.retirePending = true;
+    }
     async sendCancelButton(instanceName, correlationId, preserveProgress = false) {
         // Post first, retire after (see the tail of this method). Retiring up front
         // meant that from the delete until the new message came back — a chat API
@@ -7136,6 +7169,7 @@ export class FleetManager {
             this.logger.warn({ instanceName, topicId, groupId }, "Cannot address cancel button (no chat id resolved)");
             return;
         }
+        const publication = this.beginCancelButtonPublication(instanceName, correlationId);
         try {
             const sent = await adapter.notifyAlert(chatId, {
                 type: "cancel",
@@ -7143,6 +7177,7 @@ export class FleetManager {
                 message: "👀 處理中…",
                 choices: [{ id: `cancel:${instanceName}`, label: t("cancel.button") }],
             }, threadId ? { threadId } : undefined);
+            publication.inFlight = false;
             const entry = {
                 instanceName,
                 adapterId,
@@ -7164,6 +7199,16 @@ export class FleetManager {
                 // empty even if the daemon's reset broadcast is still in flight.
                 toolProgress: preserveProgress ? this.instanceProgress.get(instanceName) : undefined,
             };
+            // A newer send started while this API call was pending. Track this late
+            // message just long enough for the normal bounded delete/retry machinery
+            // to remove it; critically, do not sweep the newer generation.
+            if (this.cancelButtonPublications.get(instanceName) !== publication) {
+                this.cancelButtons.set(sent.messageId, entry);
+                this.persistCancelButtons();
+                this.logger.debug({ instanceName, messageId: sent.messageId, generation: publication.generation }, "Retiring superseded cancel-button publication");
+                this.retireButton(entry);
+                return;
+            }
             this.startProgressTicker(entry);
             // Idle-check backstop: every 5min, if the instance is idle, retire the
             // button. Covers turns that end without hitting a clear trigger (reply /
@@ -7200,8 +7245,30 @@ export class FleetManager {
             }
             this.persistCancelButtons();
             this.logger.info({ instanceName, messageId: sent.messageId }, "Cancel button sent");
+            // Retirement is normally edge-triggered, but the edge (or an explicit
+            // reply/cancel clear) may have happened while notifyAlert was in flight.
+            // Reconcile the level after publication so a late button cannot resurrect
+            // on an already-idle instance. Preserve the existing two-second grace:
+            // a working transition cancels this timer just as it does for a normal
+            // idle edge.
+            if (publication.retirePending) {
+                this.retireButton(entry);
+            }
+            else if (this.getInstanceExecutionState(instanceName) === "idle") {
+                this.scheduleIdleButtonRetirement(instanceName);
+            }
         }
         catch (e) {
+            if (this.cancelButtonPublications.get(instanceName) === publication) {
+                this.cancelButtonPublications.delete(instanceName);
+                // beginCancelButtonPublication cancelled the previous turn's idle
+                // timer so it could not act on this generation. If the provider POST
+                // failed while the instance remained idle, restore that retirement
+                // opportunity for any older button still on screen.
+                if (this.getInstanceExecutionState(instanceName) === "idle") {
+                    this.scheduleIdleButtonRetirement(instanceName);
+                }
+            }
             this.logger.warn({ err: e.message, instanceName }, "Failed to send cancel button");
         }
     }
@@ -7554,6 +7621,7 @@ export class FleetManager {
     }
     /** Retire all cancel buttons for an instance — on reply or cancel. */
     clearCancelButton(instanceName) {
+        this.markCancelButtonPublicationForRetirement(instanceName);
         this.retireInstanceButtons(instanceName);
     }
     /** Retire the cross-instance button matching a delegate→report correlation id.
@@ -7562,6 +7630,11 @@ export class FleetManager {
     clearCancelButtonByCorrelation(correlationId) {
         if (!correlationId)
             return;
+        for (const [instanceName, publication] of this.cancelButtonPublications) {
+            if (publication.inFlight && publication.correlationId === correlationId) {
+                this.markCancelButtonPublicationForRetirement(instanceName, publication);
+            }
+        }
         for (const e of [...this.cancelButtons.values()]) {
             if (e.correlationId === correlationId)
                 this.retireButton(e);
@@ -10299,6 +10372,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 clearInterval(entry.progressTimer);
         }
         this.cancelButtons.clear();
+        this.cancelButtonPublications.clear();
         for (const timer of this.cancelButtonIdleRetireTimers.values())
             clearTimeout(timer);
         this.cancelButtonIdleRetireTimers.clear();