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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.396",
+  "version": "0.9.82-rc.398",
   "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.396",
+    "@adhdev/mesh-shared": "0.9.82-rc.398",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -100,6 +100,10 @@ interface SendMessageState {
     maxEchoWaitMs: number;
     retryDelayMs: number;
     didCommitUserTurn: boolean;
+    // Whether this was the session's first turn at the moment of dispatch — captured
+    // before commitSendUserTurn flips this.firstTurnSent, so a later stuck-retry still
+    // knows it is recovering the win32 premature-ready first-turn swallow.
+    isFirstTurn: boolean;
 }
 
 interface SendMessageCompletion {
@@ -171,6 +175,16 @@ export class ProviderCliAdapter implements CliAdapter {
     private providerSessionId: string | null = null;
     private responseTimeout: NodeJS.Timeout | null = null;
     private 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.
+    private firstTurnSent = false;
     private startupBuffer = '';
     private startupParseGate = false;
     private startupSettleTimer: NodeJS.Timeout | null = null;
@@ -599,6 +613,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.resetTerminalScreen(DEFAULT_SESSION_HOST_ROWS, DEFAULT_SESSION_HOST_COLS);
         this.pendingTerminalQueryTail = '';
         this.ready = false;
+        // Each fresh spawn re-enters the premature-ready swallow window — the next
+        // turn is again a "first turn" and must use the win32-safe atomic send path.
+        this.firstTurnSent = false;
         await this.ptyProcess.ready;
         this.engine.onSpawnReady();
         this.scheduleStartupSettleCheck();
@@ -1210,6 +1227,9 @@ export class ProviderCliAdapter implements CliAdapter {
     private commitSendUserTurn(state: SendMessageState): void {
         if (state.didCommitUserTurn) return;
         state.didCommitUserTurn = true;
+        // The first turn has now been written atomically (win32-safe); later turns
+        // can use the normal echo-gated path now that the input layer is proven live.
+        this.firstTurnSent = true;
     }
 
     private armResponseTimeout(): void {
@@ -1240,12 +1260,31 @@ export class ProviderCliAdapter implements CliAdapter {
         });
     }
 
+    // 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).
+    private writeStuckRetry(state: SendMessageState, mode: string): void {
+        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);
+    }
+
     private retrySubmitIfStuck(state: SendMessageState, attempt: number): void {
         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; }
         this.submitRetryTimer = setTimeout(() => this.retrySubmitIfStuck(state, attempt + 1), state.retryDelayMs);
     }
@@ -1255,7 +1294,7 @@ export class ProviderCliAdapter implements CliAdapter {
         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;
     }
 
@@ -1597,6 +1636,8 @@ export class ProviderCliAdapter implements CliAdapter {
             maxEchoWaitMs,
             retryDelayMs,
             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<void>((resolve, reject) => {
@@ -1615,7 +1656,15 @@ export class ProviderCliAdapter implements CliAdapter {
                 },
             };
 
-            if (this.submitStrategy === 'immediate') {
+            // WIN32-READY-HOLD: the very first turn after startup is the one exposed to
+            // the premature-ready swallow (ready released before win32 ConPTY input is
+            // live). Force it through the atomic content+sendKey single write so the
+            // submit CR can never be separated from the text it submits — the same path
+            // the `immediate` strategy already uses. Restricted to win32 + the first
+            // turn so Mac/linux echo-gated behavior and all later turns are unchanged.
+            const useAtomicFirstTurn = this.submitStrategy === 'immediate'
+                || (process.platform === 'win32' && sendState.isFirstTurn);
+            if (useAtomicFirstTurn) {
                 this.submitImmediatePrompt(sendState, completion);
                 return;
             }

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);
@@ -2371,6 +2437,13 @@ export class DaemonCommandRouter {
                 sessionCleanupMode: refineSessionCleanupMode,
                 ...(refineSessionIds && refineSessionIds.length > 0 ? { sessionIds: refineSessionIds } : {}),
                 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,

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/mesh/mesh-queue-assignment.ts

@@ -267,7 +267,10 @@ export function tryAssignQueueTask(
     providerType: string
 ): boolean {
     const mesh = getMeshWithCache(components, meshId);
-    const node = mesh?.nodes.find((n: any) => readMeshNodeId(n) === nodeId);
+    // Match with the shared 3-form normalizer (id / nodeId / node_id), not raw
+    // `n.id` — a stamp-form nodeId vs the mesh node's config-form id must still
+    // resolve, mirroring the remote idle-session path below (:1341).
+    const node = mesh?.nodes.find((n: any) => meshNodeIdMatches(n, nodeId));
 
     // WORKTREE-CLAIM-GATE-BYPASS: the SINGLE claim-time gate for the worktree-bootstrap defer.
     // tryAssignQueueTask is the one funnel every claim path flows through — the event-driven
@@ -1317,7 +1320,7 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
 
         if (providerType) {
             localIdleSessionsChecked += 1;
-            localCandidates.push({ nodeId, sessionId, providerType, origin: 'local', node: mesh.nodes.find((n: any) => readMeshNodeId(n) === nodeId) });
+            localCandidates.push({ nodeId, sessionId, providerType, origin: 'local', node: mesh.nodes.find((n: any) => meshNodeIdMatches(n, nodeId)) });
         } else {
             skippedSessions.push({
                 nodeId,

package/src/mesh/mesh-runtime-store.ts

@@ -4,6 +4,7 @@ import { LOG } from '../logging/logger.js';
 import { loadBetterSqlite3 } from '../system/load-better-sqlite3.js';
 import { getLedgerDir } from './mesh-ledger.js';
 import { nodeSatisfiesRequiredTags } from './mesh-work-queue.js';
+import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms } from '@adhdev/mesh-shared';
 import type { MeshTaskStatus, MeshWorkQueueEntry } from './mesh-work-queue.js';
 import type BetterSqlite3 from 'better-sqlite3';
 import type { Database as DatabaseHandle } from 'better-sqlite3';
@@ -687,6 +688,15 @@ export class MeshRuntimeStore {
                 return null;
             }
 
+            // The node-pinned SELECT must match a row whose target_node_id was stamped
+            // in ANY equivalent daemon-id form (config-form `daemon_mach_X` vs the
+            // claiming session's stamp-form `mach_X`). A single `= ?` bind on the
+            // stamp-form silently fails to fetch a config-form row, leaving the task
+            // pending forever (the empty-session WORKTREE-CLAIM-GATE repro). Expand to
+            // every equivalent form and bind an IN (...) set; the per-candidate
+            // targetMatches() JS gate above re-validates each fetched row.
+            const nodeIdForms = expandDaemonIdForms(nodeId);
+            const nodePinnedPlaceholders = nodeIdForms.map(() => '?').join(', ');
             // Priority: session-targeted > node-targeted (no session) > unconstrained
             const rows = [
                 ...(
@@ -699,9 +709,9 @@ export class MeshRuntimeStore {
                 ...(
                 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) as Array<{ payload: string }>
+                `).all(meshId, ...nodeIdForms) as Array<{ payload: string }>
                 ),
                 ...(
                 this.db.prepare(`
@@ -755,9 +765,21 @@ export class MeshRuntimeStore {
             // sibling worktree session on the same daemon absorb another node's/session's
             // pinned task. When a task carries an explicit target, require an exact match
             // here too — fail-closed.
+            // The target id may have been stamped in a different serialization /
+            // daemon-id form than the claiming session's nodeId (config-form
+            // `daemon_mach_X` vs stamp-form `mach_X`, or the 3-way id/nodeId/node_id
+            // node forms). A raw `!==` here permanently strands a node-pinned task as
+            // an empty session. Accept the candidate when the target resolves to the
+            // same node under ANY equivalent form; keep targetSessionId an exact match.
             const targetMatches = (candidate: MeshWorkQueueEntry): boolean => {
                 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;
             };