@adhdev/daemon-core 0.9.82-rc.378 → 0.9.82-rc.379

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

@@ -169,6 +169,11 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private isSubmitStuck;
     private hasMeaningfulResponseBufferLocal;
     private writeToPty;
+    /** 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
+     *  trailing submit key) has been written. */
+    private writeWin32Chunked;
     private resetPendingSendState;
     private commitSendUserTurn;
     private armResponseTimeout;

package/dist/cli-adapters/pty-write-chunking.d.ts

@@ -0,0 +1,34 @@
+export declare const WIN32_PTY_WRITE_CHUNK_CHARS = 1024;
+export declare const WIN32_PTY_WRITE_CHUNK_GAP_MS = 8;
+/** Split `text` into chunks of at most `size` UTF-16 units without ever cutting
+ *  between a high and low surrogate (which would corrupt an astral char — emoji,
+ *  etc. — on the UTF-8 PTY write). */
+export declare function chunkPreservingSurrogates(text: string, size: number): string[];
+/** True when a body of `length` UTF-16 units should be paced into multiple
+ *  chunks on win32 rather than written in a single PTY write. */
+export declare function shouldChunkWin32Write(length: number): boolean;
+/**
+ * Drive a paced, surrogate-safe chunked write of `text` over a `write(chunk)`
+ * sink, calling `onChunkWritten` after each chunk (e.g. to advance an input-
+ * activity timestamp) and `onDone` once the final chunk is out. The optional
+ * `setTimer` lets the caller own the timer handle (so it can be cleared on
+ * shutdown) and supply a custom scheduler in tests; it defaults to setTimeout.
+ *
+ * Bodies at or below the chunk threshold are written in a SINGLE write — the
+ * common case — so this is a no-op pacing wrapper for normal-sized prompts.
+ *
+ * Returns the chunks that will be written (useful for assertions/logging).
+ */
+export interface PacedWin32WriteOptions {
+    write: (chunk: string) => void;
+    onChunkWritten?: () => void;
+    onDone?: () => void;
+    /** Schedule the next chunk; must return a handle the caller can clear.
+     *  Defaults to setTimeout. */
+    setTimer?: (fn: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    /** Store the pending timer handle so the caller can clear it on shutdown. */
+    onTimer?: (handle: ReturnType<typeof setTimeout> | null) => void;
+    chunkChars?: number;
+    gapMs?: number;
+}
+export declare function writeWin32Paced(text: string, opts: PacedWin32WriteOptions): string[];

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "3920b23e979544d74c4024a0ff18e5deab7b2932" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "3920b23e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.378" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-25T07:59:13.420Z" : void 0);
+  const commit = readInjected(true ? "7b74c2c74e315b3fa6eb9f18d694b79eeb561184" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "7b74c2c7" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.379" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-25T09:33:17.234Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -10371,6 +10371,16 @@ function warnDispatchWarmupGetterMissingOnce(daemonId) {
   dispatchWarmupGetterMissingWarned.add(daemonId);
   LOG.warn("MeshQueue", `Mesh peer connection getter unavailable for ${String(daemonId).slice(0, 12)}; remote task-dispatch warmup deadline degraded to the combined connect+response window. Avoids a cold-open false-timeout but loses warm/cold precision \u2014 wire getMeshPeerConnectionStatus on this daemon.`);
 }
+async function waitForLocalSessionReady(components, sessionId) {
+  const adapter = components.cliManager?.adapters?.get(sessionId);
+  if (!adapter || typeof adapter.isReady !== "function") return;
+  const deadline = Date.now() + LOCAL_LAUNCH_READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (adapter.isReady() || adapter.currentStatus === "idle") return;
+    await new Promise((resolve24) => setTimeout(resolve24, LOCAL_LAUNCH_READY_POLL_MS));
+  }
+  LOG.warn("MeshQueue", `Auto-launched session ${sessionId} not interactive after ${LOCAL_LAUNCH_READY_TIMEOUT_MS}ms; dispatching anyway (adapter queue-until-ready will buffer)`);
+}
 function deliverTaskToSession(dispatchThunk, ctx, warmup) {
   const delivery = createSessionDelivery({
     meshId: ctx.meshId,
@@ -10967,6 +10977,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
           return false;
         }
         markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId });
+        await waitForLocalSessionReady(components, sessionId);
         tryAssignQueueTask(components, meshId, nodeId, sessionId, resolved.providerType);
         return true;
       } catch (e) {
@@ -11188,7 +11199,7 @@ function runIdleMaintenanceThenAssignQueue(components, args) {
     });
   });
 }
-var import_fs12, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX;
+var import_fs12, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX;
 var init_mesh_queue_assignment = __esm({
   "src/mesh/mesh-queue-assignment.ts"() {
     "use strict";
@@ -11214,6 +11225,8 @@ var init_mesh_queue_assignment = __esm({
     DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
     DISPATCH_CONNECT_TIMEOUT_MS = MESH_CONNECT_TIMEOUT_MS;
     dispatchWarmupGetterMissingWarned = /* @__PURE__ */ new Set();
+    LOCAL_LAUNCH_READY_TIMEOUT_MS = 15e3;
+    LOCAL_LAUNCH_READY_POLL_MS = 100;
     autoLaunchInProgress = /* @__PURE__ */ new Set();
     autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
     AUTO_LAUNCH_COOLDOWN_MS = 5e3;
@@ -16997,6 +17010,34 @@ var init_pty_transport = __esm({
   }
 });
 
+// src/cli-adapters/pty-write-chunking.ts
+function chunkPreservingSurrogates(text, size) {
+  const chunks = [];
+  let offset = 0;
+  while (offset < text.length) {
+    let end = Math.min(text.length, offset + size);
+    if (end < text.length) {
+      const code = text.charCodeAt(end - 1);
+      if (code >= 55296 && code <= 56319) end -= 1;
+    }
+    if (end <= offset) end = Math.min(text.length, offset + size);
+    chunks.push(text.slice(offset, end));
+    offset = end;
+  }
+  return chunks;
+}
+function shouldChunkWin32Write(length) {
+  return length > WIN32_PTY_WRITE_CHUNK_CHARS;
+}
+var WIN32_PTY_WRITE_CHUNK_CHARS, WIN32_PTY_WRITE_CHUNK_GAP_MS;
+var init_pty_write_chunking = __esm({
+  "src/cli-adapters/pty-write-chunking.ts"() {
+    "use strict";
+    WIN32_PTY_WRITE_CHUNK_CHARS = 1024;
+    WIN32_PTY_WRITE_CHUNK_GAP_MS = 8;
+  }
+});
+
 // src/providers/sdk/v1/builders/cli/visible-region.ts
 function compile(re, flags) {
   try {
@@ -18948,6 +18989,7 @@ var init_provider_cli_adapter = __esm({
     init_terminal_screen();
     import_session_host_core5 = require("@adhdev/session-host-core");
     init_pty_transport();
+    init_pty_write_chunking();
     init_provider_cli_shared();
     init_cli_script_runner();
     init_cli_state_engine();
@@ -19426,6 +19468,7 @@ ${lastSnapshot}`;
           `[${this.cliType}] Startup settled (${trigger}, stableMs=${stableMs}, modal=${!!startupModal}) providerDir=${this.providerResolutionMeta.providerDir || "-"} scriptDir=${this.providerResolutionMeta.scriptDir || "-"} scriptsPath=${this.providerResolutionMeta.scriptsPath || "-"}`
         );
         this.onStatusChange?.();
+        if (!startupModal) this.schedulePendingOutboundFlush();
       }
       scheduleStartupSettleCheck() {
         if (!this.startupParseGate) return;
@@ -19746,8 +19789,26 @@ ${lastSnapshot}`;
       }
       async writeToPty(data) {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+        if (process.platform === "win32" && shouldChunkWin32Write(data.length)) {
+          await this.writeWin32Chunked(data);
+          return;
+        }
         await this.ptyProcess.write(data);
       }
+      /** 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
+       *  trailing submit key) has been written. */
+      async writeWin32Chunked(data) {
+        const chunks = chunkPreservingSurrogates(data, WIN32_PTY_WRITE_CHUNK_CHARS);
+        for (let i = 0; i < chunks.length; i += 1) {
+          if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+          await this.ptyProcess.write(chunks[i]);
+          if (i + 1 < chunks.length) {
+            await new Promise((resolve24) => setTimeout(resolve24, WIN32_PTY_WRITE_CHUNK_GAP_MS));
+          }
+        }
+      }
       resetPendingSendState(reason) {
         this.responseBuffer = "";
         if (this.responseTimeout) {
@@ -19995,7 +20056,13 @@ ${lastSnapshot}`;
             LOG.info("CLI", `[${this.cliType}] sendMessage recovered idle prompt readiness`);
           }
         }
-        if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.engine.currentStatus})`);
+        if (!this.ready) {
+          if (allowQueue) {
+            this.enqueuePendingOutboundMessage(text, "not_ready_pending_prompt");
+            return;
+          }
+          throw new Error(`${this.cliName} not ready (status: ${this.engine.currentStatus})`);
+        }
         const parsedSessionStatus = typeof parsedStatusBeforeSend?.status === "string" ? String(parsedStatusBeforeSend.status) : "";
         if (!allowInputDuringGeneration && (parsedSessionStatus === "generating" || parsedSessionStatus === "no_progress" || parsedSessionStatus === "long_generating")) {
           const parsedModal = parsedStatusBeforeSend?.activeModal ?? parsedStatusBeforeSend?.modal ?? null;
@@ -35606,6 +35673,7 @@ function applyPreLaunchTrust(trust, workingDir) {
 
 // src/providers/spec/fsm-driver.ts
 init_logger();
+init_pty_write_chunking();
 function countNewlines(s2) {
   let n = 0;
   for (let i = 0; i < s2.length; i += 1) if (s2.charCodeAt(i) === 10) n += 1;
@@ -35616,8 +35684,6 @@ var WIN32_SUBMIT_RESEND_GAP_MS = 350;
 var WIN32_SUBMIT_MAX_RESENDS = 14;
 var WIN32_SUBMIT_SETTLE_MS = 500;
 var WIN32_SUBMIT_SETTLE_POLL_MS = 120;
-var WIN32_PTY_WRITE_CHUNK_CHARS = 1024;
-var WIN32_PTY_WRITE_CHUNK_GAP_MS = 8;
 var WIN32_ECHO_PROBE_CHARS = 16;
 var WIN32_ECHO_MAX_WAIT_MS = 2e4;
 function normalizeForEcho(s2) {
@@ -35629,21 +35695,7 @@ function resolveSubmitDelayMs(specBeforeSubmit, text) {
   const spec = typeof specBeforeSubmit === "number" && specBeforeSubmit > 0 ? specBeforeSubmit : 0;
   return Math.max(spec, SUBMIT_DELAY_FLOOR_MS + linesBonus);
 }
-function chunkPreservingSurrogates(text, size) {
-  const chunks = [];
-  let offset = 0;
-  while (offset < text.length) {
-    let end = Math.min(text.length, offset + size);
-    if (end < text.length) {
-      const code = text.charCodeAt(end - 1);
-      if (code >= 55296 && code <= 56319) end -= 1;
-    }
-    if (end <= offset) end = Math.min(text.length, offset + size);
-    chunks.push(text.slice(offset, end));
-    offset = end;
-  }
-  return chunks;
-}
+var chunkPreservingSurrogates2 = chunkPreservingSurrogates;
 function guessExt(mime) {
   if (/png/i.test(mime)) return ".png";
   if (/jpe?g/i.test(mime)) return ".jpg";
@@ -36314,7 +36366,7 @@ var FsmDriver = class {
       this.adapter.send_keys(text);
       return;
     }
-    const chunks = chunkPreservingSurrogates(text, WIN32_PTY_WRITE_CHUNK_CHARS);
+    const chunks = chunkPreservingSurrogates2(text, WIN32_PTY_WRITE_CHUNK_CHARS);
     let idx = 0;
     const writeNext = () => {
       this.win32WriteTimer = null;
@@ -47148,8 +47200,9 @@ var meshCrudHandlers = {
           };
         }
       }
+      const explicitCleanupMode = args?.sessionCleanupMode ?? args?.session_cleanup_mode;
       const sessionCleanupMode = ctx.normalizeMeshSessionCleanupMode(
-        args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove
+        explicitCleanupMode ?? (node?.isLocalWorktree === true ? "stop_and_delete" : void 0) ?? mesh?.policy?.sessionCleanupOnNodeRemove
       );
       const explicitSessionIds = Array.isArray(args?.sessionIds) ? args.sessionIds.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
       let sessionCleanup;
@@ -47221,12 +47274,16 @@ var meshCrudHandlers = {
         }
       }
       const residueWarning = worktreeCleanup?.residue === true && typeof worktreeCleanup?.residueWarning === "string" ? worktreeCleanup.residueWarning : void 0;
+      const skippedLiveSessionIds = Array.isArray(sessionCleanup?.skippedLiveSessionIds) ? sessionCleanup.skippedLiveSessionIds.filter((v) => typeof v === "string") : [];
+      const orphanedSessionsRemaining = skippedLiveSessionIds.length > 0;
+      const orphanNextAction = orphanedSessionsRemaining ? `Live session(s) [${skippedLiveSessionIds.join(", ")}] were skipped and still survive this node removal. Run mesh_cleanup_sessions with mode:'stop_and_delete' and sessionIds:[${skippedLiveSessionIds.map((id) => `'${id}'`).join(", ")}] to release them.` : void 0;
       return {
         success: true,
         removed,
         ...residueWarning ? { residueWarning } : {},
         ...sessionCleanup ? { sessionCleanup } : {},
-        ...worktreeCleanup ? { worktreeCleanup } : {}
+        ...worktreeCleanup ? { worktreeCleanup } : {},
+        ...orphanedSessionsRemaining ? { orphanedSessionsRemaining: true, nextAction: orphanNextAction } : {}
       };
     } catch (e) {
       return { success: false, error: e.message };
@@ -52690,14 +52747,19 @@ var DaemonCommandRouter = class {
         skippedCoordinatorSessionIds.push(sessionId);
         continue;
       }
-      if (!hasExplicitSessionIds && liveRuntime && !delegateBoundToThisNode) {
+      const matchedByWorkspaceOnly = !recordNodeId;
+      const isWorktreeNodeRemoval = cleanupSource === "mesh_remove_node" && args.node?.isLocalWorktree === true;
+      const cleanWorkspaceOnlyForWorktree = isWorktreeNodeRemoval && matchedByWorkspaceOnly;
+      if (!hasExplicitSessionIds && liveRuntime && !delegateBoundToThisNode && !cleanWorkspaceOnlyForWorktree) {
         skippedSessionIds.push(sessionId);
         skippedLiveSessionIds.push(sessionId);
-        const matchedByWorkspaceOnly = !recordNodeId;
         const reason = recordNodeId && recordNodeId !== args.nodeId ? `live_delegate_bound_to_other_node:${recordNodeId}` : matchedByWorkspaceOnly ? "live_session_matched_by_workspace_only_no_node_binding" : "live_session_not_bound_to_this_node";
         skippedLiveSessionReasons.push({ sessionId, reason });
         continue;
       }
+      if (cleanWorkspaceOnlyForWorktree && !delegateBoundToThisNode) {
+        actedLiveDelegateSessionIds.push(sessionId);
+      }
       if (!hasExplicitSessionIds && liveRuntime && delegateBoundToThisNode && args.mode === "delete_stopped") {
         skippedSessionIds.push(sessionId);
         skippedLiveSessionIds.push(sessionId);