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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.397",
+  "version": "0.9.82-rc.399",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.397",
+    "@adhdev/mesh-shared": "0.9.82-rc.399",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/router.ts

@@ -727,6 +727,72 @@ export class DaemonCommandRouter {
         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.
+     */
+    public markWorktreeBootstrapTerminalState(meshId: string, nodeId: string, status: 'complete' | 'failed'): void {
+        if (!meshId || !nodeId) return;
+        const stamp = (mesh: any): boolean => {
+            if (!mesh || !Array.isArray(mesh.nodes)) return false;
+            const node = mesh.nodes.find((entry: any) => meshNodeIdMatches(entry, nodeId));
+            if (!node) return false;
+            const prev = (node.worktreeBootstrap && typeof node.worktreeBootstrap === 'object')
+                ? node.worktreeBootstrap as Record<string, unknown>
+                : {};
+            if (prev.status === status) return false;
+            node.worktreeBootstrap = {
+                ...prev,
+                status,
+                completedAt: prev.completedAt ?? new Date().toISOString(),
+            };
+            return true;
+        };
+        let changed = false;
+        // Inline cache (the authoritative view for inline-only clone worktree nodes).
+        try {
+            const cached = this.getCachedInlineMesh(meshId);
+            if (cached && stamp(cached)) {
+                cached.updatedAt = new Date().toISOString();
+                this.inlineMeshCache.set(meshId, cached);
+                changed = true;
+            }
+        } catch { /* best-effort */ }
+        if (changed) this.invalidateAggregateMeshStatus(meshId);
+        // Local config (a worktree node registered via addNode also lives here).
+        // Done in a detached dynamic-import chain so the method stays sync; both the
+        // stamp and the persist are best-effort, and the inline-cache stamp above is
+        // what the coordinator's claim gate reads.
+        void import('../config/mesh-config.js')
+            .then(({ getMesh, updateNode }) => {
+                const local = getMesh(meshId);
+                if (local && stamp(local)) {
+                    const node = local.nodes.find((entry: any) => meshNodeIdMatches(entry, nodeId));
+                    if (node) updateNode(meshId, node.id, { worktreeBootstrap: node.worktreeBootstrap } as any);
+                    this.invalidateAggregateMeshStatus(meshId);
+                }
+            })
+            .catch(() => { /* persistence is best-effort */ });
+    }
+
     private tombstoneRemovedInlineMeshNode(meshId: string, nodeId: string): void {
         if (!nodeId) return;
         let set = this.removedInlineMeshNodeIds.get(meshId);

package/src/mesh/mesh-event-forwarding.ts

@@ -1053,6 +1053,29 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         // is drained in every topology. 'failed' is re-fired too so a deferred-then-failed bootstrap
         // dispatches and fails loudly/visibly rather than stranding silently. Falls through to the
         // coordinator broadcast below — the bootstrap event is still delivered to the coordinator.
+        // WORKTREE-BOOTSTRAP-COORD-STATE: stamp the terminal bootstrap status onto the
+        // COORDINATOR's mesh view BEFORE re-firing the queue. The clone+bootstrap ran on
+        // the worker daemon (clone_mesh_node forwards to the source node's machine), so
+        // persistWorktreeSetupState only flipped status→'complete' on the worker's mesh
+        // object — the coordinator still holds the 'running' state it stamped from the
+        // forwarded clone reply. Without this, the claim gate (agent:ready defer above +
+        // mesh-queue-assignment) reads getMeshWithCache, sees 'running' forever, and
+        // defers every claim — so this very re-fire loops against a gate that never opens
+        // (claim never lands; idle session re-registered each tick; auto-launch spawns a
+        // fresh session every cycle → runaway worktree-session multiplication). Stamping
+        // the terminal state opens the gate so the deferred claim lands on this re-fire.
+        const bootstrapNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        if (bootstrapNodeId) {
+            try {
+                (components.router as any)?.markWorktreeBootstrapTerminalState?.(
+                    args.meshId,
+                    bootstrapNodeId,
+                    args.event === 'worktree_bootstrap_failed' ? 'failed' : 'complete',
+                );
+            } catch (e: any) {
+                LOG.warn('MeshQueue', `Failed to stamp terminal bootstrap state for ${bootstrapNodeId} (mesh ${args.meshId}): ${e?.message || e}`);
+            }
+        }
         setImmediate(() => {
             triggerMeshQueue(components, args.meshId).catch((e: any) => {
                 LOG.warn('MeshQueue', `Queue re-fire after ${args.event} failed (mesh ${args.meshId}): ${e?.message || e}`);

package/src/providers/cli-provider-instance.ts

@@ -2035,11 +2035,38 @@ export class CliProviderInstance implements ProviderInstance {
         const previousStatus = this.lastStatus;
         if (newStatus !== this.lastStatus) {
             LOG.info('CLI', `[${this.type}] status: ${this.lastStatus} → ${newStatus}`);
-            if (this.lastStatus === 'idle' && newStatus === 'generating') {
+            // GENERATING-MISSING (win32 fresh-worktree first-turn): a freshly-launched session
+            // is in 'starting' until its startup-grace settles to idle. When the FIRST inject
+            // lands inside that grace window, the adapter can report status DIRECTLY
+            // starting → generating without an intervening 'idle' frame for
+            // detectStatusTransition() to observe. Previously only the idle→generating arm
+            // armed the bookkeeping, so a starting→generating frame fell straight through to the
+            // bare `this.lastStatus = newStatus` update: generatingStartedAt stayed 0 and no
+            // generating_started was queued. The fast turn's generating→idle completion was then
+            // suppressed by the startup-blip guard below (generatingStartedAt===0 &&
+            // !generatingDebouncePending) — so NO generating_started AND NO generating_completed
+            // ever fired and the mesh coordinator never learned the worker went idle.
+            //
+            // We extend the idle→generating arm to also fire on starting→generating, BUT ONLY
+            // when a real turn is in flight. The adapter script can also report 'generating' from
+            // pure startup PTY noise (no task dispatched) — antigravity/codex/hermes-cli all
+            // exercise that benign starting→generating→idle blip, which must NOT emit a
+            // completion (see "startup-phase spurious completion suppression" tests).
+            // hasAdapterPendingResponse() is the discriminator: a genuine inject sets the
+            // adapter's isWaitingForResponse / currentTurnScope (or leaves a partial response),
+            // whereas startup repaint noise leaves all of them empty. So an armed
+            // starting→generating means "the worker actually started its first turn", and a
+            // bare one stays a suppressed blip via the existing fall-through.
+            const startingToGeneratingWithActiveTurn = this.lastStatus === 'starting'
+                && newStatus === 'generating'
+                && this.hasAdapterPendingResponse();
+            if (((this.lastStatus === 'idle' && newStatus === 'generating') || startingToGeneratingWithActiveTurn)) {
                 // If a completion event is already pending and the turn has ended
                 // (generatingStartedAt===0), the PTY is painting its prompt area
                 // after completing. Ignore this blip — do not cancel the pending
-                // completion and do not advance lastStatus to generating.
+                // completion and do not advance lastStatus to generating. (On a true
+                // starting→generating the session is fresh: completedDebouncePending is
+                // null, so this blip guard is a no-op and we arm normally below.)
                 if (this.completedDebouncePending && this.generatingStartedAt === 0) {
                     LOG.debug('CLI', `[${this.type}] ignoring post-completion PTY generating blip (generatingStartedAt=0)`);
                     return;