@songsid/agend 2.3.3-beta.8 → 2.3.3

package/dist/daemon.js

@@ -1264,8 +1264,19 @@ export class Daemon extends EventEmitter {
     dialogParkedSince = 0;
     /** Identity of that dialog: its pattern, not its description (two tables may describe one screen differently). */
     dialogParkedKey = null;
+    /**
+     * #2893: the held dialog whose heldReason was last logged. Its own state, not the parked clock's: the delivery probe
+     * starts that clock too, and must not use up the one log line. Cleared with the hold, so a later hold logs again.
+     */
+    heldReasonLoggedKey = null;
     dialogParkedInteractionEpisode = null;
     dialogParkedReported = false;
+    /**
+     * #2897: a "needs a human" notice is out for a dialog, and what it lives with: "parked" — the parked clock (retired when
+     * that dialog leaves the pane or another replaces it); "answer" — an answer episode of a dialog the parked clock does
+     * not track (a non-blocking one, whose scans pass no blocking dialog): retired when that episode ends.
+     */
+    parkedNoticeOut = null;
     /** #2675: the card on screen that a person can answer from the chat — what it asks, since when, and whether it was posted. */
     remoteCardShown = null;
     /** #2675: when (performance.now, taken before its capture) the newest read the card tracker used was started. */
@@ -3724,8 +3735,18 @@ export class Daemon extends EventEmitter {
                     this.noteLiveIncidentDialog(dialog, pane);
                     if (dialog.blocksDelivery || dialog.holdOnly)
                         blockingSeen = dialog;
-                    if (dialog.holdOnly)
-                        break; // recognised, deliberately not answered; trackDialogParked reports it
+                    if (dialog.holdOnly) {
+                        // Recognised, deliberately not answered; trackDialogParked reports it. Why an automatic answer passed it by
+                        // is logged once, when this hold begins (#2893).
+                        if (this.heldReasonLoggedKey !== Daemon.dialogKey(dialog)) {
+                            const reason = Daemon.heldReasonOf(dialog, pane);
+                            if (Object.keys(reason).length) {
+                                this.heldReasonLoggedKey = Daemon.dialogKey(dialog);
+                                this.logger.warn({ description: dialog.description, ...reason }, "Runtime dialog held — not auto-answering");
+                            }
+                        }
+                        break;
+                    }
                     // Reported as ignoring the daemon: the SAME request (the identity the count was made on — verbatim, the
                     // backend's own when it names one) is answered only once per DIALOG_ANSWER_BACKOFF_MS. Anything else — another
                     // request, an unexplained difference, the dialog gone — is not held back here; the answer path below ends or
@@ -3788,7 +3809,7 @@ export class Daemon extends EventEmitter {
                             return;
                         if (dialog.verifyAfterKeys && autoKey)
                             this.claimAutoDialog(dialog);
-                        this.logger.info(`Auto-dismissing runtime dialog: ${dialog.description}`);
+                        this.logger.info(Daemon.answerDetailOf(dialog, currentPane), `Auto-dismissing runtime dialog: ${dialog.description}`);
                         const SPECIAL_KEYS = new Set(["Up", "Down", "Enter", "Escape", "Right", "Left"]);
                         for (const key of dialog.keys) {
                             if (stale())
@@ -3879,8 +3900,10 @@ export class Daemon extends EventEmitter {
                 // Reached only when no dialog was answered this poll (none on screen, a fenced one, or one waiting out its
                 // backoff): unless it is the one backing off, the screen that was being answered is gone, and the next dialog is
                 // a new one.
-                if (!answersBackedOff)
+                if (!answersBackedOff && this.dialogAnswers) {
                     this.dialogAnswers = null;
+                    this.retireParkedNotice("answer");
+                }
                 this.trackDialogParked(blockingSeen);
                 this.trackRemoteCard(blockingSeen, pane, captureMono);
                 if (blockingSeen)
@@ -8435,6 +8458,7 @@ export class Daemon extends EventEmitter {
      */
     endDialogEpisode(clearParked = true) {
         this.dialogAnswers = null;
+        this.retireParkedNotice("answer");
         if (clearParked)
             this.trackDialogParked(null);
     }
@@ -8461,8 +8485,11 @@ export class Daemon extends EventEmitter {
      */
     noteDialogAnswer(dialog, outcome, screen) {
         const key = Daemon.answerKey(dialog);
-        if (!this.dialogAnswers || this.dialogAnswers.key !== key)
-            this.dialogAnswers = { key, ignored: 0, reported: false, screen, lastAnswerAt: 0 }; // the exact screen being counted: every answer in the episode saw this same one
+        if (!this.dialogAnswers || this.dialogAnswers.key !== key) {
+            if (this.dialogAnswers)
+                this.retireParkedNotice("answer"); // #2897: a different screen: the reported one is over
+            this.dialogAnswers = { key, ignored: 0, reported: false, screen, lastAnswerAt: 0 };
+        } // the exact screen being counted: every answer in the episode saw this same one
         const episode = this.dialogAnswers;
         if (outcome !== "ignored") {
             this.endDialogEpisode(outcome === "took");
@@ -8478,6 +8505,8 @@ export class Daemon extends EventEmitter {
             this.dialogParkedReported = true;
         const holdsDeliveries = dialog.blocksDelivery === true || dialog.holdOnly === true;
         this.logger.warn({ dialog: dialog.description, attempts: episode.ignored, holdsDeliveries }, "Runtime dialog is ignoring AgEnD's answer — reporting for a human");
+        // #2897: a dialog the parked clock tracks keeps its notice until it leaves the pane; any other, until this episode ends.
+        this.parkedNoticeOut = this.dialogParkedSince !== 0 && this.dialogParkedKey === Daemon.dialogKey(dialog) ? "parked" : "answer";
         this.emit("dialog_answer_ignored", { name: this.name, description: dialog.description, attempts: episode.ignored, holdsDeliveries });
     }
     /**
@@ -8551,6 +8580,24 @@ export class Daemon extends EventEmitter {
             this.remoteCardAnswering = false;
         }
     }
+    /** #2893: a held dialog's own account of why no automatic answer took it (RuntimeDialog.heldReason); {} when none. */
+    static heldReasonOf(dialog, pane) {
+        try {
+            return dialog.heldReason?.(pane) ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
+    /** What an answered dialog says about the answer (RuntimeDialog.answerDetail); {} when it gives none. */
+    static answerDetailOf(dialog, pane) {
+        try {
+            return dialog.answerDetail?.(pane) ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
     /**
      * Remember how long a blocking dialog has been on screen. Once it has
      * outlived DIALOG_PARKED_NOTIFY_MS — the auto-dismiss did not take, or the
@@ -8559,14 +8606,24 @@ export class Daemon extends EventEmitter {
      * is safe. Identity is the pattern, so the delivery gate and the runtime
      * scanner (same canonical list) never reset each other's clock.
      */
+    /** #2897: the notice out for a dialog is out of date (its `owner` ended): the fleet takes it back. */
+    retireParkedNotice(owner) {
+        if (this.parkedNoticeOut !== owner)
+            return;
+        this.parkedNoticeOut = null;
+        this.emit("dialog_unparked", { name: this.name });
+    }
     trackDialogParked(dialog) {
         if (!dialog) {
             if (this.dialogParkedSince !== 0)
                 this.logger.info({ dialog: this.dialogParkedKey }, "Blocking dialog is gone from the pane");
             this.dialogParkedSince = 0;
             this.dialogParkedKey = null;
+            this.heldReasonLoggedKey = null;
             this.dialogParkedInteractionEpisode = null;
             this.dialogParkedReported = false;
+            // #2897: whatever it posted is out of date — the fleet takes its notices back.
+            this.retireParkedNotice("parked");
             return;
         }
         const key = Daemon.dialogKey(dialog);
@@ -8578,6 +8635,9 @@ export class Daemon extends EventEmitter {
         if (episode !== null)
             this.dialogParkedInteractionEpisode = episode;
         if (this.dialogParkedSince === 0 || this.dialogParkedKey !== key) {
+            // #2897: a different dialog replaced the one being tracked — that one's notices are out of date.
+            if (this.dialogParkedSince !== 0)
+                this.retireParkedNotice("parked");
             this.dialogParkedSince = Date.now();
             this.dialogParkedKey = key;
             this.dialogParkedReported = false;
@@ -8589,6 +8649,7 @@ export class Daemon extends EventEmitter {
             this.dialogParkedReported = true;
         if (!this.dialogParkedReported && Date.now() - this.dialogParkedSince >= (unrecognised ? 0 : DIALOG_PARKED_NOTIFY_MS)) {
             this.dialogParkedReported = true;
+            this.parkedNoticeOut = "parked";
             this.logger.warn({ dialog: dialog.description, parkedForMs: Date.now() - this.dialogParkedSince }, "CLI dialog is still on screen — not auto-answering, reporting for a human");
             this.emit("dialog_parked", { name: this.name, description: dialog.description, holdOnly: dialog.holdOnly === true,
                 ...(dialog.parkedAdvice ? { advice: dialog.parkedAdvice } : {}),
@@ -11427,6 +11488,13 @@ export class Daemon extends EventEmitter {
         this.recoveryNativeWork = false;
         this.recoveryCancelled = false;
         this.dialogAnswers = null;
+        // #2897: a relaunched CLI shows none of the old dialogs — whatever notice was out for one is out of date.
+        // A dialog still tracked when the new CLI shows it again is reported afresh (its old notice is gone).
+        if (this.parkedNoticeOut) {
+            this.parkedNoticeOut = null;
+            this.dialogParkedReported = false;
+            this.emit("dialog_unparked", { name: this.name });
+        }
         this.cancelCapacityNudge("the instance was stopped, paused or respawned");
         this.lastErrorEpisode = null;
         this.nudgeBaselines = null;
@@ -12809,6 +12877,8 @@ export class Daemon extends EventEmitter {
                         this.noteCodexReserveDialog(dialog, pane);
                         this.noteLiveIncidentDialog(dialog, pane);
                         cleanReadyPolls = 0;
+                        // Before the parked clock below claims it: a hold seen for the first time is said once, with its reason (#2893).
+                        const firstSight = this.dialogParkedKey !== Daemon.dialogKey(dialog);
                         // Start the parked clock for every delivery-blocking dialog, exact
                         // ones included: if the auto-dismiss keeps failing here, the human
                         // report should count from first sight, not from the runtime scan.
@@ -12837,14 +12907,16 @@ export class Daemon extends EventEmitter {
                         }
                         if (dialog.holdOnly) {
                             // Recognised but deliberately not answered (see RuntimeDialog.holdOnly).
-                            if (this.dialogParkedKey !== Daemon.dialogKey(dialog)) {
-                                this.logger.warn({ description: dialog.description }, "Startup dialog held — not auto-answering, deliveries stay blocked");
+                            if (firstSight) {
+                                const reason = this.heldReasonLoggedKey !== Daemon.dialogKey(dialog) ? Daemon.heldReasonOf(dialog, pane) : {};
+                                if (Object.keys(reason).length)
+                                    this.heldReasonLoggedKey = Daemon.dialogKey(dialog);
+                                this.logger.warn({ description: dialog.description, ...reason }, "Startup dialog held — not auto-answering, deliveries stay blocked");
                             }
                             this.trackDialogParked(dialog);
                             matched = true;
                             break;
                         }
-                        this.logger.info(`Dismissing startup dialog: ${dialog.description}`);
                         // Restart is exactly when inbound messages pile up, and nothing gates
                         // delivery on `spawning`. Take the pane lock for the key sequence so a
                         // queued message cannot be pasted into a half-dismissed trust dialog.
@@ -12857,6 +12929,7 @@ export class Daemon extends EventEmitter {
                             // a pane that is no longer this launch's is not read or keyed.
                             if (!owned())
                                 return false;
+                            let answeredPane = pane;
                             if (dialog.inputBlocked) {
                                 const currentPane = await this.tmux.capturePane();
                                 this.startupAdmission?.();
@@ -12865,7 +12938,10 @@ export class Daemon extends EventEmitter {
                                     return false;
                                 if (!Daemon.dialogMatches(dialog, currentPane))
                                     return false;
+                                answeredPane = currentPane;
                             }
+                            // Said of the screen actually answered — the one re-read under the lock (#2896 review).
+                            this.logger.info(Daemon.answerDetailOf(dialog, answeredPane), `Dismissing startup dialog: ${dialog.description}`);
                             if (dialog.autoResolutionKey) {
                                 attemptedSafetyChoices.add(dialog.autoResolutionKey);
                                 this.claimAutoDialog(dialog);