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

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 ? "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);
+  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;
 }
@@ -14672,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}`);
@@ -53061,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);