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

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/commands/router.d.ts

@@ -203,6 +203,29 @@ export declare class DaemonCommandRouter {
     private requireMeshHostMutationOwner;
     private updateInlineMeshNode;
     private removeInlineMeshNode;
+    /**
+     * 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: string, nodeId: string, status: 'complete' | 'failed'): void;
     private tombstoneRemovedInlineMeshNode;
     /** Filter an incoming inline mesh against this mesh's tombstones before it is
      *  reconciled into the cache. A tombstoned node is dropped only while its

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 ? "a572a9e7fe0e92e33a309d89e35299ad42aa407d" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "a572a9e7" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = 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:08.687Z" : 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,
@@ -14667,6 +14672,18 @@ function injectMeshSystemMessage(components, args) {
       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) {
+        LOG.warn("MeshQueue", `Failed to stamp terminal bootstrap state for ${bootstrapNodeId} (mesh ${args.meshId}): ${e?.message || e}`);
+      }
+    }
     setImmediate(() => {
       triggerMeshQueue(components, args.meshId).catch((e) => {
         LOG.warn("MeshQueue", `Queue re-fire after ${args.event} failed (mesh ${args.meshId}): ${e?.message || e}`);
@@ -19596,6 +19613,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 +19909,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 +20374,7 @@ ${lastSnapshot}`;
       commitSendUserTurn(state) {
         if (state.didCommitUserTurn) return;
         state.didCommitUserTurn = true;
+        this.firstTurnSent = true;
       }
       armResponseTimeout() {
         if (this.responseTimeout) clearTimeout(this.responseTimeout);
@@ -20368,12 +20397,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 +20432,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 +20685,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 +20705,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;
           }
@@ -53023,6 +53073,64 @@ var DaemonCommandRouter = class {
     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 set = this.removedInlineMeshNodeIds.get(meshId);
@@ -54406,7 +54514,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,