@adhdev/daemon-standalone 1.0.58-rc.43 → 1.0.58-rc.45

package/dist/index.js

@@ -36911,10 +36911,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "47890c7d415cdbcb3ce67972b0351e36477e8a27" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "47890c7d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.43" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-29T16:10:45.187Z" : void 0);
+      const commit = readInjected(true ? "f678a3c56c08e7876a714abda968b9e6a8787841" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "f678a3c5" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.45" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-30T01:11:37.487Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -51080,7 +51080,8 @@ ${lines.join("\n")}
       });
       if (!stamp2) return event;
       const dispatchedBySelfFallback = selfFallback && stamp2.scope === "broadcast";
-      const selfFallbackTarget = dispatchedBySelfFallback && !readNonEmptyString(event.targetCoordinatorDaemonId) && !readNonEmptyString(event.targetCoordinatorSessionId) ? readNonEmptyString(stamp2.dispatchedBy.daemonId) : void 0;
+      const isWorktreeBootstrapEvent = event.event === "worktree_bootstrap_complete" || event.event === "worktree_bootstrap_failed";
+      const selfFallbackTarget = dispatchedBySelfFallback && !isWorktreeBootstrapEvent && !readNonEmptyString(event.targetCoordinatorDaemonId) && !readNonEmptyString(event.targetCoordinatorSessionId) ? readNonEmptyString(stamp2.dispatchedBy.daemonId) : void 0;
       return {
         ...event,
         protocolVersion: stamp2.protocolVersion,
@@ -79188,6 +79189,47 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim_backoff", nodeId, sessionId });
       return "backoff";
     }
+    function remoteGeneratingKey(meshId, sessionId) {
+      return `${meshId}::${sessionId}`;
+    }
+    function markRemoteSessionGenerating(meshId, sessionId) {
+      if (!meshId || !sessionId) return;
+      remoteGeneratingSessions.add(remoteGeneratingKey(meshId, sessionId));
+    }
+    function markRemoteSessionIdle(meshId, sessionId) {
+      if (!meshId || !sessionId) return;
+      remoteGeneratingSessions.delete(remoteGeneratingKey(meshId, sessionId));
+    }
+    function isRemoteSessionMarkedGenerating(meshId, sessionId) {
+      if (!meshId || !sessionId) return false;
+      return remoteGeneratingSessions.has(remoteGeneratingKey(meshId, sessionId));
+    }
+    function claimAfterRemoteAutoLaunch(components, meshId, nodeId, sessionId, providerType, assignQueueTask) {
+      if (!sessionId) return "no_session";
+      if (isRemoteSessionMarkedGenerating(meshId, sessionId)) {
+        LOG2.info("MeshQueue", `Remote auto-launch claim skipped for session ${sessionId} on node ${nodeId} (mesh ${meshId}): generating_started observed \u2014 fail-closed, will not inject into a mid-turn worker`);
+        return "skipped_generating";
+      }
+      try {
+        MeshRuntimeStore.getInstance().setRemoteIdleSession(
+          meshId,
+          nodeId,
+          sessionId,
+          providerType,
+          Date.now() + AUTO_LAUNCH_REMOTE_IDLE_TTL_MS
+        );
+      } catch {
+      }
+      const assigned = assignQueueTask(components, meshId, nodeId, sessionId, providerType);
+      if (assigned) {
+        try {
+          MeshRuntimeStore.getInstance().deleteRemoteIdleSession(meshId, nodeId, sessionId);
+        } catch {
+        }
+        return "claimed";
+      }
+      return "registered";
+    }
     var AUTO_LAUNCH_AWAIT_CLAIM_MS;
     var AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
     var AUTO_LAUNCH_REMOTE_IDLE_TTL_MS;
@@ -79196,6 +79238,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var autoLaunchOrphanFirstSeenAtMs;
     var AUTO_LAUNCH_ORPHAN_GRACE_MS;
     var autoLaunchAwaitClaimBackoff;
+    var remoteGeneratingSessions;
     var init_mesh_autolaunch_integrity = __esm2({
       "src/mesh/mesh-autolaunch-integrity.ts"() {
         "use strict";
@@ -79216,6 +79259,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         autoLaunchOrphanFirstSeenAtMs = /* @__PURE__ */ new Map();
         AUTO_LAUNCH_ORPHAN_GRACE_MS = 3e4;
         autoLaunchAwaitClaimBackoff = /* @__PURE__ */ new Map();
+        remoteGeneratingSessions = /* @__PURE__ */ new Set();
       }
     });
     function classifiedDifficultiesForSlot(slot) {
@@ -81035,12 +81079,18 @@ ${block2.text}`,
         if (!localId) continue;
         const inlineMatch = cachedNodes.find((cachedNode) => meshNodeIdMatches(cachedNode, localId));
         if (!inlineMatch) continue;
-        if (!inlineBootstrapIsFresher(inlineMatch.worktreeBootstrap, localNode.worktreeBootstrap)) continue;
+        const bootstrapFresher = inlineBootstrapIsFresher(inlineMatch.worktreeBootstrap, localNode.worktreeBootstrap);
+        const inlineGit = inlineMatch.lastGit ?? inlineMatch.last_git;
+        if (!bootstrapFresher && !inlineGit) continue;
         if (!overlaid) {
           overlaidLocalNodes = [...localNodes];
           overlaid = true;
         }
-        overlaidLocalNodes[i] = { ...localNode, worktreeBootstrap: inlineMatch.worktreeBootstrap };
+        overlaidLocalNodes[i] = {
+          ...localNode,
+          ...bootstrapFresher ? { worktreeBootstrap: inlineMatch.worktreeBootstrap } : {},
+          ...inlineGit ? { lastGit: inlineGit, last_git: inlineGit } : {}
+        };
       }
       if (!cacheOnly.length && !overlaid) return localMesh;
       return { ...localMesh, nodes: [...overlaidLocalNodes, ...cacheOnly] };
@@ -81337,7 +81387,12 @@ ${block2.text}`,
           return void 0;
         }
       })();
-      const bootstrapGateNode = inlineBootstrapNode ?? node;
+      const bootstrapGateNode = (() => {
+        const base = inlineBootstrapNode ?? node;
+        if (!base) return base;
+        const git3 = inlineBootstrapNode?.lastGit ?? inlineBootstrapNode?.last_git ?? node?.lastGit ?? node?.last_git;
+        return git3 ? { ...base, lastGit: git3, last_git: git3 } : base;
+      })();
       if (bootstrapGateNode?.worktreeBootstrap?.status === "running") {
         if (!shouldDeferDispatchForBootstrap(bootstrapGateNode)) {
           logWorktreeBootstrapStaleBypass(meshId, nodeId, sessionId);
@@ -82130,6 +82185,7 @@ ${block2.text}`,
                   await waitForRemoteSessionReady(meshId, nodeId, remoteSessionId, {
                     isReady: remoteSessionReadyProbe(meshId, nodeId, remoteSessionId)
                   }).catch(() => false);
+                  claimAfterRemoteAutoLaunch(components, meshId, nodeId, remoteSessionId, effectiveProviderType, tryAssignQueueTask);
                 }
                 return true;
               }
@@ -85973,6 +86029,7 @@ ${cleanBody}`;
           }
           if (nodeId && providerType) {
             if (!isFalseIdle) {
+              markRemoteSessionIdle(args.meshId, sessionId);
               sweepExpiredRemoteIdleSessions();
               try {
                 MeshRuntimeStore.getInstance().setRemoteIdleSession(args.meshId, nodeId, sessionId, providerType, Date.now() + REMOTE_IDLE_SESSION_TTL_MS);
@@ -86050,6 +86107,7 @@ ${cleanBody}`;
             worktreeBootstrapPending = node?.worktreeBootstrap?.status === "running";
           } catch {
           }
+          markRemoteSessionIdle(args.meshId, sessionId);
           sweepExpiredRemoteIdleSessions();
           try {
             MeshRuntimeStore.getInstance().setRemoteIdleSession(args.meshId, nodeId, sessionId, providerType, Date.now() + REMOTE_IDLE_SESSION_TTL_MS);
@@ -86080,6 +86138,7 @@ ${cleanBody}`;
           }
         }
         if (sessionId) {
+          markRemoteSessionGenerating(args.meshId, sessionId);
           const startedTaskId = readNonEmptyString(args.metadataEvent.taskId) || void 0;
           const startedNonce = typeof args.metadataEvent.dispatchNonce === "number" ? args.metadataEvent.dispatchNonce : void 0;
           if (startedTaskId && startedNonce !== void 0) {
@@ -86187,6 +86246,7 @@ ${cleanBody}`;
           }
         }
         if (sessionId) {
+          markRemoteSessionIdle(args.meshId, sessionId);
           directDispatchTaskIdForLedger = readNonEmptyString(args.metadataEvent.taskId) || resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
           completedTaskForLedger = markSessionTerminal(sessionId, "failed");
         }
@@ -86195,11 +86255,17 @@ ${cleanBody}`;
         if (bootstrapNodeId) {
           try {
             const bootstrapWorkspace = readNonEmptyString(args.metadataEvent.worktreePath) || readNonEmptyString(args.metadataEvent.workspace);
+            const originDaemonId = readNonEmptyString(args.metadataEvent.originDaemonId) || readNonEmptyString(args.metadataEvent.daemonId);
+            const originMachineId = readNonEmptyString(args.metadataEvent.originMachineId) || readNonEmptyString(args.metadataEvent.machineId);
             components.router.markWorktreeBootstrapTerminalState(
               args.meshId,
               bootstrapNodeId,
               args.event === "worktree_bootstrap_failed" ? "failed" : "complete",
-              bootstrapWorkspace ? { workspace: bootstrapWorkspace } : void 0
+              bootstrapWorkspace || originDaemonId || originMachineId ? {
+                ...bootstrapWorkspace ? { workspace: bootstrapWorkspace } : {},
+                ...originDaemonId ? { daemonId: originDaemonId } : {},
+                ...originMachineId ? { machineId: originMachineId } : {}
+              } : void 0
             );
           } catch (e) {
             LOG2.error("MeshQueue", `Failed to stamp terminal bootstrap state for ${bootstrapNodeId} (mesh ${args.meshId}): ${e?.message || e}`);
@@ -86528,6 +86594,10 @@ ${cleanBody}`;
         interactionId: readNonEmptyString(payload.interactionId),
         status: readNonEmptyString(payload.status),
         targetDaemonId: readNonEmptyString(payload.targetDaemonId),
+        // Worker origin identity for a remotely cloned worktree's bootstrap event
+        // so the coordinator's hydrate-on-miss upsert is P2P-addressable.
+        originDaemonId: readNonEmptyString(payload.originDaemonId) || readNonEmptyString(payload.daemonId) || readNonEmptyString(payload.metadataEvent?.originDaemonId),
+        originMachineId: readNonEmptyString(payload.originMachineId) || readNonEmptyString(payload.machineId) || readNonEmptyString(payload.metadataEvent?.originMachineId),
         startedAt: readNonEmptyString(payload.startedAt),
         completedAt: readNonEmptyString(payload.completedAt),
         retryOfJobId: readNonEmptyString(payload.retryOfJobId),
@@ -86850,6 +86920,7 @@ ${cleanBody}`;
         init_mesh_event_classify();
         init_mesh_turn_ledger();
         init_mesh_queue_assignment();
+        init_mesh_autolaunch_integrity();
         init_mesh_event_suppression();
         init_mesh_event_suppression();
         REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
@@ -87080,10 +87151,24 @@ ${cleanBody}`;
       return [];
     }
     function extractPendingEvents(raw) {
-      if (Array.isArray(raw)) return raw;
-      if (raw && typeof raw === "object") {
-        const events = raw.events;
-        if (Array.isArray(events)) return events;
+      let cursor = raw;
+      for (let depth = 0; depth < 4 && cursor && typeof cursor === "object"; depth++) {
+        if (Array.isArray(cursor)) return cursor;
+        const record2 = cursor;
+        if (Array.isArray(record2.events)) return record2.events;
+        if (record2.payload && typeof record2.payload === "object") {
+          cursor = record2.payload;
+          continue;
+        }
+        if (record2.result && typeof record2.result === "object") {
+          cursor = record2.result;
+          continue;
+        }
+        if (record2.data && typeof record2.data === "object") {
+          cursor = record2.data;
+          continue;
+        }
+        break;
       }
       return [];
     }
@@ -137541,6 +137626,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             try {
               const durationMs = Date.now() - startedAtMs;
               const event = `worktree_${eventStatus2}`;
+              const hostDaemonId = readNonEmptyString(mesh?.meshHost?.hostDaemonId);
               const metadataEvent = {
                 source: "clone_mesh_node_bootstrap",
                 nodeId: node.id,
@@ -137548,6 +137634,9 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                 worktreePath: result.worktreePath,
                 durationMs,
                 bootstrapStatus: bootstrapState2.status,
+                ...hostDaemonId ? { targetCoordinatorDaemonId: hostDaemonId } : {},
+                ...effectiveDaemonId ? { originDaemonId: effectiveDaemonId } : {},
+                ...effectiveMachineId ? { originMachineId: effectiveMachineId } : {},
                 ...bootstrapState2.error ? { error: bootstrapState2.error } : {},
                 ...bootstrapState2.exitCode !== void 0 ? { exitCode: bootstrapState2.exitCode } : {},
                 ...extraPayload || {}
@@ -137562,7 +137651,16 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                         getCachedInlineMesh: ctx.getCachedInlineMesh
                       }
                     },
-                    { event, meshId, nodeId: node.id, workspace: result.worktreePath, metadataEvent }
+                    {
+                      event,
+                      meshId,
+                      nodeId: node.id,
+                      workspace: result.worktreePath,
+                      metadataEvent,
+                      ...hostDaemonId ? { targetCoordinatorDaemonId: hostDaemonId } : {},
+                      ...effectiveDaemonId ? { originDaemonId: effectiveDaemonId } : {},
+                      ...effectiveMachineId ? { originMachineId: effectiveMachineId } : {}
+                    }
                   );
                   if (forwarded?.success === true) return;
                 } catch {
@@ -137575,7 +137673,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                 nodeId: node.id,
                 workspace: result.worktreePath,
                 metadataEvent,
-                queuedAt: Date.now()
+                queuedAt: Date.now(),
+                ...hostDaemonId ? { targetCoordinatorDaemonId: hostDaemonId } : {}
               });
             } catch {
             }
@@ -141844,6 +141943,11 @@ ${ptyResult.output.slice(-2e3)}`);
               nodeId,
               isLocalWorktree: true,
               ...opts?.workspace ? { workspace: opts.workspace } : {},
+              // Origin identity from the worker's bootstrap event: without
+              // these, isLocalAutoLaunchNode treats the shell as LOCAL and the
+              // coordinator tries to spawn the remote worktree on itself.
+              ...opts?.daemonId ? { daemonId: opts.daemonId } : {},
+              ...opts?.machineId ? { machineId: opts.machineId } : {},
               worktreeBootstrap: terminalBootstrap()
             };
             this.updateInlineMeshNode(meshId, shell, hydratedNode);