@adhdev/daemon-standalone 0.9.82-rc.397 → 0.9.82-rc.399

package/dist/index.js

@@ -30108,10 +30108,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "5e6a6bcc5ba51a08f3941445f431cb0411217547" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "5e6a6bcc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:34:04.661Z" : void 0);
+      const commit = readInjected(true ? "a77fca338e386be4785dcfb7e765826155817728" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "a77fca33" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.399" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-27T10:13:09.933Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -44479,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}`);
@@ -70005,7 +70017,8 @@ ${body}
         const previousStatus = this.lastStatus;
         if (newStatus !== this.lastStatus) {
           LOG2.info("CLI", `[${this.type}] status: ${this.lastStatus} \u2192 ${newStatus}`);
-          if (this.lastStatus === "idle" && newStatus === "generating") {
+          const startingToGeneratingWithActiveTurn = this.lastStatus === "starting" && newStatus === "generating" && this.hasAdapterPendingResponse();
+          if (this.lastStatus === "idle" && newStatus === "generating" || startingToGeneratingWithActiveTurn) {
             if (this.completedDebouncePending && this.generatingStartedAt === 0) {
               LOG2.debug("CLI", `[${this.type}] ignoring post-completion PTY generating blip (generatingStartedAt=0)`);
               return;
@@ -82592,6 +82605,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);