@adhdev/daemon-standalone 0.9.82-rc.363 → 0.9.82-rc.364

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "4c5b30b1b0527ec5234c037893ba4fc24b88a8a0" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "4c5b30b1" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.363" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-23T16:14:01.927Z" : void 0);
+      const commit = readInjected(true ? "1428e9d027beefe860a77f34dea34d202db80f00" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "1428e9d0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.364" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-24T00:06:20.085Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -64729,6 +64729,11 @@ ${body}
       lastWin32WriteAt = 0;
       /** Pending paced chunk-write timer for a large win32 body (see writeWin32Body). */
       win32WriteTimer = null;
+      /** Timer driving the win32 verification-based modal-confirm CR resend loop (see
+       *  scheduleWin32ModalConfirm). A lone CR that confirms an approval/picker choice
+       *  is absorbed by ConPTY the same way a send_message submit CR is, so the confirm
+       *  must be resent until the modal actually resolves (status leaves 'approval'). */
+      win32ModalConfirmTimer = null;
       currentEval = null;
       stateHistory = [];
       prevStateAt = 0;
@@ -64853,6 +64858,10 @@ ${body}
           clearTimeout(this.win32WriteTimer);
           this.win32WriteTimer = null;
         }
+        if (this.win32ModalConfirmTimer) {
+          clearTimeout(this.win32ModalConfirmTimer);
+          this.win32ModalConfirmTimer = null;
+        }
         this.specWatcher?.close();
         this.adapter.kill();
       }
@@ -65448,10 +65457,61 @@ ${body}
           const nav = step.repeat(Math.abs(delta));
           const confirm = (rule.key_for_index || "\r").replace(/\{index\}/g, "") || "\r";
           if (nav) this.adapter.send_keys(nav);
-          this.adapter.send_keys(confirm);
+          this.submitModalConfirm(confirm);
+          return;
+        }
+        this.submitModalConfirm(btn.key);
+      }
+      /**
+       * Submit a modal-confirm key sequence (the choice key + its trailing CR).
+       *
+       * On win32 the trailing CR is the SAME lone-CR-swallow case as a send_message
+       * submit: ConPTY can absorb a single CR as a literal newline instead of a
+       * confirm, so the approval/picker modal never resolves and the FSM flaps
+       * approval↔busy while auto-approve keeps firing into the void (APPROVESTUCK).
+       * So we split any non-CR prefix (e.g. the "1" of "1\r") off, write it once, and
+       * resend the CR on a fixed cadence until the modal actually resolves (status
+       * leaves 'approval'). Non-win32 keeps the single direct write — its CR submits
+       * on the first try.
+       */
+      submitModalConfirm(keys) {
+        if (process.platform !== "win32") {
+          this.adapter.send_keys(keys);
           return;
         }
-        this.adapter.send_keys(btn.key);
+        const m = /^([\s\S]*?)([\r\n]+)$/.exec(keys);
+        const prefix = m ? m[1] : keys;
+        const cr = m ? m[2] : "";
+        if (prefix) this.adapter.send_keys(prefix);
+        if (!cr) return;
+        this.scheduleWin32ModalConfirm(cr);
+      }
+      /**
+       * win32 modal-confirm CR resend loop. Mirrors scheduleWin32Submit's phase-2
+       * verified resend, but gated on still being IN a modal (status 'approval')
+       * rather than still idle: the first CR fires immediately, then resends every
+       * WIN32_SUBMIT_RESEND_GAP_MS while the FSM is still showing the modal, up to
+       * WIN32_SUBMIT_MAX_RESENDS. The instant the modal resolves (status flips to
+       * generating/idle) we stop, so no stray CR leaks into the next turn's composer.
+       */
+      scheduleWin32ModalConfirm(submitKey) {
+        if (this.win32ModalConfirmTimer) {
+          clearTimeout(this.win32ModalConfirmTimer);
+          this.win32ModalConfirmTimer = null;
+        }
+        const fire = (attempt) => {
+          this.win32ModalConfirmTimer = null;
+          this.adapter.send_keys(submitKey);
+          if (attempt + 1 >= WIN32_SUBMIT_MAX_RESENDS) return;
+          this.win32ModalConfirmTimer = setTimeout(() => {
+            if (this.currentStatus() !== "approval") {
+              this.win32ModalConfirmTimer = null;
+              return;
+            }
+            fire(attempt + 1);
+          }, WIN32_SUBMIT_RESEND_GAP_MS);
+        };
+        fire(0);
       }
       handleAttachImage(blob, mime) {
         const ctl = (this.spec.control_bar ?? []).find((c) => c.action.type === "attach_image");