@adhdev/daemon-standalone 0.9.82-rc.396 → 0.9.82-rc.398

package/dist/index.js

@@ -30108,10 +30108,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "109c5230408ea2b33e9083395b42b1c3e894aed2" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "109c5230" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:16:08.131Z" : void 0);
+      const commit = readInjected(true ? "a572a9e7fe0e92e33a309d89e35299ad42aa407d" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "a572a9e7" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.398" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-27T09:05:37.974Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -34977,6 +34977,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         init_load_better_sqlite3();
         init_mesh_ledger();
         init_mesh_work_queue();
+        init_dist();
         loggedMigrationFailure = false;
         MeshRuntimeStore = class _MeshRuntimeStore {
           static instance;
@@ -35509,6 +35510,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
               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
@@ -35517,9 +35520,9 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
                 `).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
@@ -35549,7 +35552,9 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
               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));
@@ -40570,7 +40575,7 @@ Next step: ${nextStep}`;
     }
     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") {
         LOG2.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)`);
@@ -41179,7 +41184,7 @@ Next step: ${nextStep}`;
         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,
@@ -44474,6 +44479,18 @@ ${cleanBody}`;
           completedTaskForLedger = markSessionTerminal(sessionId, "failed");
         }
       } else if (args.event === "worktree_bootstrap_complete" || args.event === "worktree_bootstrap_failed") {
+        const bootstrapNodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
+        if (bootstrapNodeId) {
+          try {
+            components.router?.markWorktreeBootstrapTerminalState?.(
+              args.meshId,
+              bootstrapNodeId,
+              args.event === "worktree_bootstrap_failed" ? "failed" : "complete"
+            );
+          } catch (e) {
+            LOG2.warn("MeshQueue", `Failed to stamp terminal bootstrap state for ${bootstrapNodeId} (mesh ${args.meshId}): ${e?.message || e}`);
+          }
+        }
         setImmediate(() => {
           triggerMeshQueue(components, args.meshId).catch((e) => {
             LOG2.warn("MeshQueue", `Queue re-fire after ${args.event} failed (mesh ${args.meshId}): ${e?.message || e}`);
@@ -49400,6 +49417,16 @@ ${cont}` : cont;
           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;
@@ -49686,6 +49713,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();
@@ -50150,6 +50178,7 @@ ${lastSnapshot}`;
           commitSendUserTurn(state) {
             if (state.didCommitUserTurn) return;
             state.didCommitUserTurn = true;
+            this.firstTurnSent = true;
           }
           armResponseTimeout() {
             if (this.responseTimeout) clearTimeout(this.responseTimeout);
@@ -50172,12 +50201,30 @@ ${lastSnapshot}`;
               LOG2.warn("CLI", `[${this.cliType}] ${mode} write failed: ${error48?.message || error48}`);
             });
           }
+          // 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) {
+              LOG2.info("CLI", `[${this.cliType}] ${mode}: re-typing full prompt atomically (win32 first-turn swallow recovery)`);
+              void this.writeToPty(state.text + this.sendKey).catch((error48) => {
+                LOG2.warn("CLI", `[${this.cliType}] ${mode} re-type write failed: ${error48?.message || error48}`);
+              });
+              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;
             LOG2.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;
@@ -50189,7 +50236,7 @@ ${lastSnapshot}`;
             if (!this.isSubmitStuck(state.normalizedPromptSnippet)) return;
             this.engine.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
             LOG2.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) {
@@ -50442,7 +50489,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) => {
@@ -50460,7 +50509,8 @@ ${lastSnapshot}`;
                   reject(error48);
                 }
               };
-              if (this.submitStrategy === "immediate") {
+              const useAtomicFirstTurn = this.submitStrategy === "immediate" || process.platform === "win32" && sendState.isFirstTurn;
+              if (useAtomicFirstTurn) {
                 this.submitImmediatePrompt(sendState, completion);
                 return;
               }
@@ -82554,6 +82604,64 @@ ${mergeTreeErr?.stderr || ""}`;
         this.invalidateAggregateMeshStatus(meshId);
         return true;
       }
+      /**
+       * WORKTREE-BOOTSTRAP-COORD-STATE: mark a worktree node's bootstrap as reaching a
+       * terminal state (complete / failed) in THIS daemon's mesh view.
+       *
+       * Root cause this fixes: clone_mesh_node forwards the clone+bootstrap to the
+       * source node's daemon (the worktree's machine). persistWorktreeSetupState
+       * therefore flips worktreeBootstrap.status to 'complete' on the WORKER daemon's
+       * mesh object — never on the coordinator's. The coordinator only ever holds the
+       * 'running' state it stamped from the forwarded clone reply. The claim path's
+       * bootstrap gate (mesh-event-forwarding agent:ready / mesh-queue-assignment)
+       * reads the coordinator's mesh via getMeshWithCache, sees status==='running'
+       * forever, and DEFERS every claim — so the worktree_bootstrap_complete re-fire
+       * (triggerMeshQueue) loops against a gate that never opens: claim never lands,
+       * the idle session is re-registered each tick, and auto-launch keeps spawning
+       * fresh sessions (runaway worktree-session multiplication).
+       *
+       * Called from the worktree_bootstrap_complete/_failed event handler BEFORE the
+       * queue re-fire so the gate sees the terminal state and the deferred claim can
+       * finally land. Updates the inline cache (clone worktree nodes are inline-only)
+       * and, when the node also exists in local config, persists there too; both paths
+       * invalidate the aggregate status cache. Best-effort and idempotent.
+       */
+      markWorktreeBootstrapTerminalState(meshId, nodeId, status) {
+        if (!meshId || !nodeId) return;
+        const stamp = (mesh) => {
+          if (!mesh || !Array.isArray(mesh.nodes)) return false;
+          const node = mesh.nodes.find((entry) => meshNodeIdMatches(entry, nodeId));
+          if (!node) return false;
+          const prev = node.worktreeBootstrap && typeof node.worktreeBootstrap === "object" ? node.worktreeBootstrap : {};
+          if (prev.status === status) return false;
+          node.worktreeBootstrap = {
+            ...prev,
+            status,
+            completedAt: prev.completedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+          };
+          return true;
+        };
+        let changed = false;
+        try {
+          const cached3 = this.getCachedInlineMesh(meshId);
+          if (cached3 && stamp(cached3)) {
+            cached3.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            this.inlineMeshCache.set(meshId, cached3);
+            changed = true;
+          }
+        } catch {
+        }
+        if (changed) this.invalidateAggregateMeshStatus(meshId);
+        void Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports)).then(({ getMesh: getMesh2, updateNode: updateNode2 }) => {
+          const local = getMesh2(meshId);
+          if (local && stamp(local)) {
+            const node = local.nodes.find((entry) => meshNodeIdMatches(entry, nodeId));
+            if (node) updateNode2(meshId, node.id, { worktreeBootstrap: node.worktreeBootstrap });
+            this.invalidateAggregateMeshStatus(meshId);
+          }
+        }).catch(() => {
+        });
+      }
       tombstoneRemovedInlineMeshNode(meshId, nodeId) {
         if (!nodeId) return;
         let set2 = this.removedInlineMeshNodeIds.get(meshId);
@@ -83937,7 +84045,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,