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

package/dist/mesh/mesh-events-stale.d.ts

@@ -34,6 +34,15 @@ export declare function reconcileDirectDispatchCompletionFromTranscript(args: {
     transcriptMessageAt?: string;
     completedAt?: string;
     targetCoordinatorDaemonId?: string;
+    /**
+     * NOTIF-DROP-SYNTH-NO-MESSAGE: the originating coordinator SESSION that dispatched this
+     * task (the `coordinatorSessionId` stamped onto the task_dispatched ledger payload at
+     * dispatch). Stamped onto the synthesized completion's targetCoordinatorSessionId so PHASE 2
+     * STRICT routing matches the exact coordinator session — instead of relying on the
+     * daemon-keyed fallback. When the caller does not pass it, it is recovered from the dispatch
+     * ledger entry below; absent on legacy rows → daemon-level routing (unchanged).
+     */
+    targetCoordinatorSessionId?: string;
     source?: string;
 }): {
     reconciled: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.395",
+  "version": "0.9.82-rc.397",
   "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.395",
+    "@adhdev/mesh-shared": "0.9.82-rc.397",
     "@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

@@ -2371,6 +2371,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-events-stale.ts

@@ -3,7 +3,7 @@ import type { MeshLedgerKind } from './mesh-ledger.js';
 import { updateDirectDispatchStatus, cleanupTerminalDirectDispatches } from './mesh-work-queue.js';
 import { markSessionDeliveriesTerminal } from './mesh-delivery-policy.js';
 import { queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
-import { readNonEmptyString, readRecord, resolveEventSessionId, readWorkerResultMetadata, isWeakCompletionEvidence } from './mesh-events-utils.js';
+import { readNonEmptyString, readRecord, resolveEventSessionId, readWorkerResultMetadata, isWeakCompletionEvidence, buildMeshSystemMessage } from './mesh-events-utils.js';
 import { meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 
 // ---------------------------------------------------------------------------
@@ -188,6 +188,15 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
     transcriptMessageAt?: string;
     completedAt?: string;
     targetCoordinatorDaemonId?: string;
+    /**
+     * NOTIF-DROP-SYNTH-NO-MESSAGE: the originating coordinator SESSION that dispatched this
+     * task (the `coordinatorSessionId` stamped onto the task_dispatched ledger payload at
+     * dispatch). Stamped onto the synthesized completion's targetCoordinatorSessionId so PHASE 2
+     * STRICT routing matches the exact coordinator session — instead of relying on the
+     * daemon-keyed fallback. When the caller does not pass it, it is recovered from the dispatch
+     * ledger entry below; absent on legacy rows → daemon-level routing (unchanged).
+     */
+    targetCoordinatorSessionId?: string;
     source?: string;
 }): { reconciled: boolean; kind?: MeshLedgerKind; alreadyTerminal?: boolean; workerResult?: unknown; ledgerEntryId?: string; reason?: string } {
     const finalSummary = readNonEmptyString(args.finalSummary);
@@ -282,27 +291,44 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
     updateDirectDispatchStatus(args.meshId, args.sessionId, kind === 'task_completed' ? 'completed' : 'failed', args.taskId);
     markSessionDeliveriesTerminal(args.meshId, args.sessionId, kind === 'task_completed' ? 'completed' : 'failed');
     setImmediate(() => cleanupTerminalDirectDispatches());
+    // NOTIF-DROP-SYNTH-NO-MESSAGE: the queued synth completion MUST carry a coordinatorMessage,
+    // or injectPendingIntoCoordinator early-returns (`!pending.coordinatorMessage`) and the row is
+    // drained-without-inject → no [System] surface. The ~8s-later native completion then collides
+    // on the taskId-anchored fingerprint and is blocked at INSERT, so the notification is lost
+    // forever. Build the SAME [System] message the native path builds (buildMeshSystemMessage) so
+    // the synth is itself a complete, deliverable completion. Routing is made STRICT too: stamp the
+    // originating coordinator session so PHASE 2 strict-match delivers to the exact coordinator
+    // session that dispatched the task instead of falling back to a daemon-level broadcast.
+    const eventName = kind === 'task_completed' ? 'agent:generating_completed' : 'agent:stopped';
+    const nodeLabel = nodeId ? `Node '${nodeId}'` : 'Remote agent';
+    const metadataEvent = {
+        targetSessionId: args.sessionId,
+        providerType: providerType || undefined,
+        providerSessionId: readNonEmptyString(args.providerSessionId),
+        finalSummary,
+        taskId: args.taskId,
+        workerResult,
+        completionDiagnostic: {
+            reason: 'direct_task_transcript_reconciliation',
+            terminalLedgerKind: kind,
+            terminalLedgerId: entry.id,
+        },
+    };
+    // Originating coordinator session: prefer the explicit arg; otherwise recover it from the
+    // task_dispatched ledger payload (the MCP dispatch path stamps `coordinatorSessionId` there).
+    // Absent on legacy rows → undefined → daemon-level routing (unchanged, no regression).
+    const targetCoordinatorSessionId = readNonEmptyString(args.targetCoordinatorSessionId)
+        || readNonEmptyString(dispatch?.payload?.coordinatorSessionId);
     queuePendingMeshCoordinatorEvent({
-        event: kind === 'task_completed' ? 'agent:generating_completed' : 'agent:stopped',
+        event: eventName,
         meshId: args.meshId,
-        nodeLabel: nodeId ? `Node '${nodeId}'` : 'Remote agent',
+        nodeLabel,
         nodeId: nodeId || undefined,
-        metadataEvent: {
-            targetSessionId: args.sessionId,
-            providerType: providerType || undefined,
-            providerSessionId: readNonEmptyString(args.providerSessionId),
-            finalSummary,
-            taskId: args.taskId,
-            workerResult,
-            completionDiagnostic: {
-                reason: 'direct_task_transcript_reconciliation',
-                terminalLedgerKind: kind,
-                terminalLedgerId: entry.id,
-            },
-        },
-        coordinatorMessage: undefined,
+        metadataEvent,
+        coordinatorMessage: buildMeshSystemMessage({ event: eventName, nodeLabel, metadataEvent }),
         queuedAt: Date.now(),
         ...(readNonEmptyString(args.targetCoordinatorDaemonId) ? { targetCoordinatorDaemonId: readNonEmptyString(args.targetCoordinatorDaemonId) } : {}),
+        ...(targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}),
     });
 
     return { reconciled: true, kind, workerResult, ledgerEntryId: entry.id };

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-reconcile-loop.ts

@@ -55,7 +55,7 @@ import {
     ackUnresolvedDelegateForward,
     expireStaleUnresolvedDelegateForwards,
 } from './mesh-unresolved-forward-outbox.js';
-import { readNonEmptyString, readMeshCompletionSummary } from './mesh-events-utils.js';
+import { readNonEmptyString, readMeshCompletionSummary, buildMeshSystemMessage } from './mesh-events-utils.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { expandDaemonIdForms, daemonIdsEquivalent } from '@adhdev/mesh-shared';
 import { getActiveDirectDispatches, getQueue, reclaimStrandedAssignedTask, updateTaskStatus } from './mesh-work-queue.js';
@@ -368,7 +368,30 @@ function injectPendingIntoCoordinator(
     coordinator: LiveCoordinator['instance'],
     pending: PendingMeshCoordinatorEvent,
 ): void {
-    if (!coordinator || !pending.coordinatorMessage) return;
+    if (!coordinator) return;
+    // NOTIF-DROP-SYNTH-NO-MESSAGE (defence-in-depth): a queued event with no coordinatorMessage
+    // used to be dropped here (drain-without-inject) — the row had already been consumed
+    // (drained=1) by the caller's drain, so silently returning lost it forever. The primary fix
+    // makes the transcript-reconcile synth always carry a coordinatorMessage, but as a backstop,
+    // lazily synthesize the [System] text for any force-inject (terminal: completion / approval /
+    // stop / refine·bootstrap) event that still arrives message-less, so it surfaces instead of
+    // vanishing. A NON-force lifecycle event (agent:ready / generating_started) legitimately
+    // carries no message and must NOT be injected (it is queued only to re-drive the claim state
+    // machine on pull) — for it we still return without injecting.
+    let coordinatorMessage = pending.coordinatorMessage;
+    if (!coordinatorMessage) {
+        if (!shouldForceInjectMeshEvent(pending.event)) return;
+        const metadataEvent = pending.metadataEvent && typeof pending.metadataEvent === 'object'
+            ? pending.metadataEvent
+            : {};
+        coordinatorMessage = buildMeshSystemMessage({
+            event: pending.event,
+            nodeLabel: pending.nodeLabel,
+            metadataEvent,
+        });
+        if (!coordinatorMessage) return; // builder produced nothing — nothing to surface
+        LOG.warn('MeshReconcile', `Lazily synthesized missing coordinatorMessage for ${pending.event} (mesh ${pending.meshId}) at inject time — a queued terminal event arrived message-less`);
+    }
     const force = shouldForceInjectMeshEvent(pending.event);
     // EVTTRACE: event surfaced to the coordinator (injected into its live CLI session).
     // This is the terminal happy-path stage. Observation only.
@@ -380,7 +403,7 @@ function injectPendingIntoCoordinator(
         event: pending.event,
     }, force ? 'force-inject' : 'inject');
     coordinator.onEvent('send_message', {
-        input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage },
+        input: { text: coordinatorMessage, textFallback: coordinatorMessage },
         ...(force ? { force: true } : {}),
     });
 }

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;
             };