@adhdev/daemon-core 0.9.82-rc.489 → 0.9.82-rc.490

package/dist/cli-adapters/provider-cli-adapter.d.ts

@@ -64,6 +64,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private pendingOutboundFlushTimer;
     private pendingOutboundFlushInFlight;
     private submitRetryTimer;
+    private ptyWriteChain;
     private resizeSuppressUntil;
     private readonly runner;
     /** @deprecated use runner.cliScripts for direct script access */
@@ -172,7 +173,14 @@ export declare class ProviderCliAdapter implements CliAdapter {
     setInteractivePromptResponse(_response: InteractivePromptResponse): Promise<void>;
     private isSubmitStuck;
     private hasMeaningfulResponseBufferLocal;
+    /** Serialize `data` onto the per-session PTY write chain. Returns a promise
+     *  that resolves (or rejects) with THIS write's own outcome, so callers keep
+     *  their existing "await my write completion" semantics. The underlying chain
+     *  link swallows its own error before releasing the next write, so a failed
+     *  write surfaces to its caller but never wedges subsequent writes behind a
+     *  permanently-rejected tail (FIFO order preserved). */
     private writeToPty;
+    private doWriteToPty;
     /** Write `data` to the PTY in bounded, surrogate-safe chunks with a short
      *  inter-chunk gap (win32 paced write). Awaits each chunk's write and the gap
      *  so the returned promise resolves only after the FINAL chunk (carrying any

package/dist/index.js

@@ -414,10 +414,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "b268e41ee8422d976c6774101d93809b131860e9" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "b268e41e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.489" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-10T04:37:55.985Z" : void 0);
+  const commit = readInjected(true ? "cfa673de50d6ede347cf424b9cab1e94081eadb2" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "cfa673de" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.490" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-10T05:30:12.581Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -25791,6 +25791,16 @@ var init_provider_cli_adapter = __esm({
       pendingOutboundFlushInFlight = false;
       // Submit retry timer — PTY-level, not state machine
       submitRetryTimer = null;
+      // PTY-WRITE-SERIALIZE: a single per-session tail promise that serializes every
+      // PTY write. Each writeToPty() call chains its actual write after the previous
+      // one and returns a promise that resolves only after ITS write completes, so
+      // two consecutive sends (e.g. mesh force-dispatch burst → forceSendMessage, or
+      // a retry-timer's bare CR interleaving a fresh body) can never write into the
+      // same input line: message A's (body + sendKey/CR) is fully written to the PTY
+      // before message B's body write starts. The chain is kept alive across errors
+      // (each link swallows/logs its own failure) so one failed write never wedges
+      // all later writes behind a permanently-rejected tail.
+      ptyWriteChain = Promise.resolve();
       // Resize redraw suppression
       resizeSuppressUntil = 0;
       // (A2.2) Native transcript anchor moved to CHAT_SOURCE_REGISTRY.
@@ -26526,7 +26536,19 @@ ${lastSnapshot}`;
         }
         return true;
       }
-      async writeToPty(data) {
+      /** Serialize `data` onto the per-session PTY write chain. Returns a promise
+       *  that resolves (or rejects) with THIS write's own outcome, so callers keep
+       *  their existing "await my write completion" semantics. The underlying chain
+       *  link swallows its own error before releasing the next write, so a failed
+       *  write surfaces to its caller but never wedges subsequent writes behind a
+       *  permanently-rejected tail (FIFO order preserved). */
+      writeToPty(data) {
+        const run = this.ptyWriteChain.then(() => this.doWriteToPty(data));
+        this.ptyWriteChain = run.catch(() => {
+        });
+        return run;
+      }
+      async doWriteToPty(data) {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         if (process.platform === "win32" && shouldChunkWin32Write(data.length)) {
           await this.writeWin32Chunked(data);