@adhdev/daemon-standalone 1.0.42-rc.1 → 1.0.42-rc.2

package/dist/index.js

@@ -36556,10 +36556,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "d424e843d3ebe663ebdd8ca6c46cd47355f45eba" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "d424e843" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.42-rc.1" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-10T14:31:55.387Z" : void 0);
+      const commit = readInjected(true ? "887aef0e08676616ce97395698e7690167982603" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "887aef0e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.42-rc.2" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-10T17:37:45.509Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -93131,6 +93131,13 @@ ${marker}`,
       return n;
     }
     var SUBMIT_DELAY_FLOOR_MS = 200;
+    var SEND_IN_FLIGHT_MAX_MS = 3e4;
+    var DUPLICATE_RESEND_WINDOW_MS = 6e4;
+    function hashSendText(text) {
+      let h = 5381;
+      for (let i = 0; i < text.length; i += 1) h = ((h << 5) + h ^ text.charCodeAt(i)) >>> 0;
+      return `${h.toString(36)}:${text.length}`;
+    }
     var fsmDriverSeq = 0;
     var WIN32_SUBMIT_RESEND_GAP_MS = 350;
     var WIN32_SUBMIT_MAX_RESENDS = 14;
@@ -93237,6 +93244,19 @@ ${marker}`,
       //    non-busy ("ready") state — same contract as v3's idleSeenOnce.
       readySeenOnce = false;
       pendingSends = [];
+      /** True while a send is written but the FSM has not yet left idle, i.e. the
+       *  composer is mid-submit. Blocks a second send from overwriting the first
+       *  before the CLI has consumed it (see handleSendMessage). */
+      sendInFlight = false;
+      /** Wall-clock (ms) the in-flight send was written. Bounds sendInFlight so a
+       *  send the CLI never visibly consumed cannot wedge the queue forever. */
+      sendInFlightAt = 0;
+      /** Content hash → wall-clock of the last PTY write, for the pre-write
+       *  duplicate gate (see isDuplicateResend). */
+      recentSendHashes = /* @__PURE__ */ new Map();
+      /** Pending queued-send drain timer, tracked so shutdown() can cancel it and
+       *  a torn-down driver never writes a queued body into a dead PTY. */
+      pendingSendDrainTimer = null;
       pickerInProgress = null;
       delegateTimers = /* @__PURE__ */ new Map();
       specWatcher = null;
@@ -93389,6 +93409,11 @@ ${marker}`,
           clearTimeout(this.win32ModalConfirmTimer);
           this.win32ModalConfirmTimer = null;
         }
+        if (this.pendingSendDrainTimer) {
+          clearTimeout(this.pendingSendDrainTimer);
+          this.pendingSendDrainTimer = null;
+        }
+        this.pendingSends.length = 0;
         this.specWatcher?.close();
         this.adapter.kill();
       }
@@ -93580,12 +93605,14 @@ ${marker}`,
           this.scheduleWakeForState();
           this.scheduleStallWatchdog();
           this.maybeMarkReady();
+          this.drainPendingSends();
           return;
         }
         this.emitStateChanged(forceEmit);
         this.scheduleWakeForState();
         this.scheduleStallWatchdog();
         this.maybeMarkReady();
+        this.drainPendingSends();
       }
       commitTransition(fired, now, ev) {
         const from = this.currentStateId;
@@ -93855,8 +93882,7 @@ ${marker}`,
         if (!st) return;
         if (!st.initial && statusForState(st) === "idle") {
           this.readySeenOnce = true;
-          const queued = this.pendingSends.splice(0);
-          for (const text of queued) setTimeout(() => this.actuallySendMessage(text), 50);
+          this.drainPendingSends();
         }
       }
       // ────────────────────────────────────────────────────────────────────
@@ -93894,13 +93920,109 @@ ${marker}`,
       // ────────────────────────────────────────────────────────────────────
       // Dashboard commands (identical semantics to v3)
       // ────────────────────────────────────────────────────────────────────
+      /**
+       * SEND-OVERLAP gate. A send may only go straight to the PTY when the machine
+       * is genuinely able to accept one: it has been ready at least once, it is
+       * sitting at an idle prompt right now, and no earlier send is still in flight.
+       * Anything else is queued and drained by drainPendingSends() when the machine
+       * next returns to idle.
+       *
+       * Before the fix this consulted ONLY `readySeenOnce` — a one-shot latch — so
+       * every send after the first ignored the live FSM state and could be written
+       * on top of a still-generating turn, braiding the two bodies in the composer
+       * (see the SEND-OVERLAP note above the constants).
+       */
       handleSendMessage(text) {
-        if (!this.readySeenOnce) {
+        if (this.isDuplicateResend(text)) {
+          LOG2.info("FsmDriver", `[${this.specTag()}] send suppressed \u2014 duplicate resend within ${DUPLICATE_RESEND_WINDOW_MS}ms (len=${text.length})`);
+          return;
+        }
+        if (!this.canSendNow()) {
           this.pendingSends.push(text);
+          LOG2.info(
+            "FsmDriver",
+            `[${this.specTag()}] send queued \u2014 ${this.sendBlockedReason()} (len=${text.length}, queued=${this.pendingSends.length})`
+          );
           return;
         }
+        this.beginSend(text);
+      }
+      /** True when a send can be written to the PTY right now. */
+      canSendNow() {
+        if (!this.readySeenOnce) return false;
+        if (this.isSendInFlight()) return false;
+        return this.currentStatus() === "idle";
+      }
+      /** Human-readable reason a send was queued — logged, never used for control flow. */
+      sendBlockedReason() {
+        if (!this.readySeenOnce) return "machine not ready yet";
+        if (this.isSendInFlight()) return `previous send still in flight (${Date.now() - this.sendInFlightAt}ms)`;
+        return `machine is ${this.currentStatus()}`;
+      }
+      /** In-flight latch with its self-expiry applied, so a send the CLI never
+       *  visibly consumed cannot wedge the queue permanently. */
+      isSendInFlight() {
+        if (!this.sendInFlight) return false;
+        if (Date.now() - this.sendInFlightAt > SEND_IN_FLIGHT_MAX_MS) {
+          LOG2.warn("FsmDriver", `[${this.specTag()}] in-flight send latch expired after ${SEND_IN_FLIGHT_MAX_MS}ms \u2014 releasing`);
+          this.sendInFlight = false;
+          return false;
+        }
+        return true;
+      }
+      /**
+       * Pre-write duplicate gate. Suppresses a repeat of text that was written to
+       * the PTY within DUPLICATE_RESEND_WINDOW_MS *while that text is still being
+       * processed* — i.e. a send is in flight or the machine has not returned to
+       * idle. A genuine repeat typed at an idle prompt is NOT suppressed: sending
+       * "continue" twice in a row is ordinary use, and silently swallowing the
+       * second one would be a worse defect than the one being fixed.
+       */
+      isDuplicateResend(text) {
+        const now = Date.now();
+        const key2 = hashSendText(text);
+        for (const [candidate, at] of this.recentSendHashes) {
+          if (now - at > DUPLICATE_RESEND_WINDOW_MS) this.recentSendHashes.delete(candidate);
+        }
+        const previous = this.recentSendHashes.get(key2);
+        if (previous === void 0) return false;
+        if (now - previous > DUPLICATE_RESEND_WINDOW_MS) return false;
+        const stillProcessing = this.isSendInFlight() || this.currentStatus() !== "idle" || this.pendingSends.length > 0;
+        return stillProcessing;
+      }
+      /** Mark a send as in flight, record it for the duplicate gate, and write it. */
+      beginSend(text) {
+        this.sendInFlight = true;
+        this.sendInFlightAt = Date.now();
+        this.recentSendHashes.set(hashSendText(text), this.sendInFlightAt);
         this.actuallySendMessage(text);
       }
+      /**
+       * Release the in-flight latch and write the next queued send, if the machine
+       * can take one. Called from the FSM evaluation loop, so it runs on the same
+       * frame the machine reaches idle — the queue never waits for an extra PTY
+       * frame that a quiet CLI would never produce (the same hazard maybeMarkReady
+       * documents for the very first message).
+       */
+      drainPendingSends() {
+        if (!this.readySeenOnce) return;
+        const status = this.currentStatus();
+        if (this.sendInFlight && status !== "idle") {
+          this.sendInFlight = false;
+        }
+        if (status !== "idle") return;
+        if (this.isSendInFlight()) return;
+        if (this.pendingSends.length === 0) return;
+        const next = this.pendingSends.shift();
+        LOG2.info("FsmDriver", `[${this.specTag()}] draining queued send (len=${next.length}, remaining=${this.pendingSends.length})`);
+        if (this.pendingSendDrainTimer) clearTimeout(this.pendingSendDrainTimer);
+        this.pendingSendDrainTimer = setTimeout(() => {
+          this.pendingSendDrainTimer = null;
+          this.beginSend(next);
+        }, 50);
+        this.sendInFlight = true;
+        this.sendInFlightAt = Date.now();
+      }
       actuallySendMessage(text) {
         const sm = this.spec.send_message;
         const perChar = sm.delay_ms_per_char ?? 0;