@adhdev/daemon-core 0.9.82-rc.396 → 0.9.82-rc.397

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

@@ -39,6 +39,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private providerSessionId;
     private responseTimeout;
     private ready;
+    private firstTurnSent;
     private startupBuffer;
     private startupParseGate;
     private startupSettleTimer;
@@ -178,6 +179,7 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private commitSendUserTurn;
     private armResponseTimeout;
     private writeSubmitKeyForRetry;
+    private writeStuckRetry;
     private retrySubmitIfStuck;
     private retryImmediateSubmitIfStuck;
     private submitSendKey;

package/dist/index.js

@@ -383,10 +383,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "109c5230408ea2b33e9083395b42b1c3e894aed2" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "109c5230" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.396" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-27T07:15:39.648Z" : void 0);
+  const commit = readInjected(true ? "5e6a6bcc5ba51a08f3941445f431cb0411217547" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "5e6a6bcc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.397" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-27T08:32:58.380Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -5197,6 +5197,7 @@ var init_mesh_runtime_store = __esm({
     init_load_better_sqlite3();
     init_mesh_ledger();
     init_mesh_work_queue();
+    init_dist();
     loggedMigrationFailure = false;
     MeshRuntimeStore = class _MeshRuntimeStore {
       static instance;
@@ -5729,6 +5730,8 @@ var init_mesh_runtime_store = __esm({
           if (providerType && typeof providerMaxParallel === "number" && Number.isFinite(providerMaxParallel) && providerMaxParallel >= 0 && this.activeProviderAssignmentCount(meshId, nodeId, providerType) >= providerMaxParallel) {
             return null;
           }
+          const nodeIdForms = expandDaemonIdForms(nodeId);
+          const nodePinnedPlaceholders = nodeIdForms.map(() => "?").join(", ");
           const rows = [
             ...this.db.prepare(`
                     SELECT payload FROM mesh_queue
@@ -5737,9 +5740,9 @@ var init_mesh_runtime_store = __esm({
                 `).all(meshId, sessionId),
             ...this.db.prepare(`
                     SELECT payload FROM mesh_queue
-                    WHERE mesh_id = ? AND status = 'pending' AND target_node_id = ? AND target_session_id IS NULL
+                    WHERE mesh_id = ? AND status = 'pending' AND target_node_id IN (${nodePinnedPlaceholders}) AND target_session_id IS NULL
                     ORDER BY created_at ASC
-                `).all(meshId, nodeId),
+                `).all(meshId, ...nodeIdForms),
             ...this.db.prepare(`
                     SELECT payload FROM mesh_queue
                     WHERE mesh_id = ? AND status = 'pending' AND target_node_id IS NULL AND target_session_id IS NULL
@@ -5769,7 +5772,9 @@ var init_mesh_runtime_store = __esm({
           const convergenceAllows = (candidate) => candidate.taskMode !== "convergence" || !nodeIsWorktree;
           const targetMatches = (candidate) => {
             if (candidate.targetSessionId && candidate.targetSessionId !== sessionId) return false;
-            if (candidate.targetNodeId && candidate.targetNodeId !== nodeId) return false;
+            if (candidate.targetNodeId && !daemonIdsEquivalent(candidate.targetNodeId, nodeId) && !meshNodeIdMatches({ id: candidate.targetNodeId }, nodeId)) {
+              return false;
+            }
             return true;
           };
           const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && convergenceAllows(candidate) && targetMatches(candidate) && nodeConflictAllows(candidate));
@@ -10783,7 +10788,7 @@ function deliverTaskToSession(dispatchThunk, ctx, warmup) {
 }
 function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
   const mesh = getMeshWithCache(components, meshId);
-  const node = mesh?.nodes.find((n) => readMeshNodeId(n) === nodeId);
+  const node = mesh?.nodes.find((n) => meshNodeIdMatches(n, nodeId));
   const gateNode = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
   if (gateNode?.worktreeBootstrap?.status === "running") {
     LOG.info("MeshQueue", `Gating queue claim for worktree node ${nodeId} (${sessionId}): worktree bootstrap still running \u2014 task left pending; claim re-fires once bootstrap reaches a terminal state (guards against dispatching into a half-built worktree \u2192 empty session)`);
@@ -11392,7 +11397,7 @@ async function triggerMeshQueue(components, meshId) {
     const providerType = state.type || readNonEmptyString2(settings.providerType);
     if (providerType) {
       localIdleSessionsChecked += 1;
-      localCandidates.push({ nodeId, sessionId, providerType, origin: "local", node: mesh.nodes.find((n) => readMeshNodeId(n) === nodeId) });
+      localCandidates.push({ nodeId, sessionId, providerType, origin: "local", node: mesh.nodes.find((n) => meshNodeIdMatches(n, nodeId)) });
     } else {
       skippedSessions.push({
         nodeId,
@@ -19596,6 +19601,16 @@ var init_provider_cli_adapter = __esm({
       providerSessionId = null;
       responseTimeout = null;
       ready = false;
+      // WIN32-READY-HOLD: the ready barrier can release on screen/spec-FSM grace
+      // before win32 ConPTY's input layer is live. The first split write (text, then a
+      // separate trailing CR via waitForEchoAndSubmit) then has its submit CR swallowed,
+      // and every CR-only retry re-sends a bare CR the input layer keeps dropping — the
+      // first message is typed-but-never-submitted and lost. Routing only the FIRST turn
+      // through the atomic content+sendKey single write (submitImmediatePrompt) keeps the
+      // Enter in the same PTY write unit as the text, the invariant win32 ConPTY needs to
+      // recognize a submit, so the swallow is bypassed. Subsequent turns (input layer now
+      // proven live) keep the normal echo-gated path. Flips true on first committed turn.
+      firstTurnSent = false;
       startupBuffer = "";
       startupParseGate = false;
       startupSettleTimer = null;
@@ -19882,6 +19897,7 @@ ${lastSnapshot}`;
         this.resetTerminalScreen(import_session_host_core5.DEFAULT_SESSION_HOST_ROWS, import_session_host_core5.DEFAULT_SESSION_HOST_COLS);
         this.pendingTerminalQueryTail = "";
         this.ready = false;
+        this.firstTurnSent = false;
         await this.ptyProcess.ready;
         this.engine.onSpawnReady();
         this.scheduleStartupSettleCheck();
@@ -20346,6 +20362,7 @@ ${lastSnapshot}`;
       commitSendUserTurn(state) {
         if (state.didCommitUserTurn) return;
         state.didCommitUserTurn = true;
+        this.firstTurnSent = true;
       }
       armResponseTimeout() {
         if (this.responseTimeout) clearTimeout(this.responseTimeout);
@@ -20368,12 +20385,30 @@ ${lastSnapshot}`;
           LOG.warn("CLI", `[${this.cliType}] ${mode} write failed: ${error?.message || error}`);
         });
       }
+      // WIN32-READY-HOLD: choose the retry write for a stuck prompt. When the FIRST turn
+      // is stuck on win32 — the premature-ready swallow window — the prompt text itself
+      // may have been partially eaten by a not-yet-live ConPTY input layer, so re-sending
+      // a bare CR keeps hitting nothing. Re-type the whole `text + sendKey` atomically
+      // once so the input layer (now live) receives a self-contained, submit-coupled
+      // write. All other cases keep the cheap bare-CR retry (the prompt is fully echoed
+      // and only the Enter is missing).
+      writeStuckRetry(state, mode) {
+        const retypeFirstTurn = process.platform === "win32" && state.isFirstTurn;
+        if (retypeFirstTurn) {
+          LOG.info("CLI", `[${this.cliType}] ${mode}: re-typing full prompt atomically (win32 first-turn swallow recovery)`);
+          void this.writeToPty(state.text + this.sendKey).catch((error) => {
+            LOG.warn("CLI", `[${this.cliType}] ${mode} re-type write failed: ${error?.message || error}`);
+          });
+          return;
+        }
+        this.writeSubmitKeyForRetry(mode);
+      }
       retrySubmitIfStuck(state, attempt) {
         this.submitRetryTimer = null;
         if (!this.isSubmitStuck(state.normalizedPromptSnippet)) return;
         this.engine.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
         LOG.info("CLI", `[${this.cliType}] Retrying submit key for stuck prompt (attempt ${attempt})`);
-        this.writeSubmitKeyForRetry("submit_retry");
+        this.writeStuckRetry(state, "submit_retry");
         if (attempt >= 3) {
           this.engine.submitRetryUsed = true;
           return;
@@ -20385,7 +20420,7 @@ ${lastSnapshot}`;
         if (!this.isSubmitStuck(state.normalizedPromptSnippet)) return;
         this.engine.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
         LOG.info("CLI", `[${this.cliType}] Retrying submit key for stuck prompt (attempt 1)`);
-        this.writeSubmitKeyForRetry("immediate_retry");
+        this.writeStuckRetry(state, "immediate_retry");
         this.engine.submitRetryUsed = true;
       }
       submitSendKey(state, completion) {
@@ -20638,7 +20673,9 @@ ${lastSnapshot}`;
           submitDelayMs,
           maxEchoWaitMs,
           retryDelayMs,
-          didCommitUserTurn: false
+          didCommitUserTurn: false,
+          // Capture BEFORE the send commits — commitSendUserTurn flips firstTurnSent.
+          isFirstTurn: !this.firstTurnSent
         };
         this.engine.responseSettleIgnoreUntil = Date.now() + submitDelayMs + this.timeouts.outputSettle + 250;
         await new Promise((resolve24, reject) => {
@@ -20656,7 +20693,8 @@ ${lastSnapshot}`;
               reject(error);
             }
           };
-          if (this.submitStrategy === "immediate") {
+          const useAtomicFirstTurn = this.submitStrategy === "immediate" || process.platform === "win32" && sendState.isFirstTurn;
+          if (useAtomicFirstTurn) {
             this.submitImmediatePrompt(sendState, completion);
             return;
           }
@@ -54406,7 +54444,14 @@ ${hintLines.join("\n")}` : "",
       nodeId,
       sessionCleanupMode: refineSessionCleanupMode,
       ...refineSessionIds && refineSessionIds.length > 0 ? { sessionIds: refineSessionIds } : {},
-      inlineMesh: args?.inlineMesh
+      inlineMesh: args?.inlineMesh,
+      // REFINE-CLEANUP: refine reaches cleanup only AFTER a verified merge
+      // convergence, so any residual worktree dirtiness here is incidental
+      // (e.g. a bootstrap lockfile rewrite) — never unmerged work. `force`
+      // sets requireClean=false so a plain-dirty worktree no longer aborts
+      // removal with merged_cleanup_failed. Branch-ref deletion still keys off
+      // mergeConvergence (NOT the force flag), so no merged work can be lost.
+      force: true
     });
     recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
       removed: removeResult?.removed,