@adhdev/daemon-core 0.9.82-rc.501 → 0.9.82-rc.503

package/dist/providers/cli-provider-instance.d.ts

@@ -145,6 +145,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private busyEpoch;
     private fastCollapseSynthesizedTaskId;
     private startupGraceCollapseAt;
+    private meshTaskInjectedAt;
     private settings;
     private monitor;
     private generatingDebounceTimer;
@@ -440,6 +441,31 @@ export declare class CliProviderInstance implements ProviderInstance {
      * turn completes overwrites it. Returns undefined for a non-task ad-hoc turn.
      */
     private completingTurnTaskId;
+    /**
+     * ANTIGRAVITY-PREMATURE-COMPLETION gate: has the CURRENTLY-injected task actually
+     * entered generating (a real onTurnStarted for it)? Used to reject stale external-
+     * native completion evidence that predates the injected task's turn.
+     *
+     * The injected task's id is the session scalar `meshActiveTaskId`, stamped by
+     * attachMeshAssignment BEFORE the PTY turn starts. That stamp also records
+     * `meshTaskInjectedAt`. The turn that has genuinely started is marked by
+     * `adapter.currentTurnStartedAt` (set ONLY by onTurnStarted). Two naive signals both
+     * FAIL for a reused-idle session:
+     *  - `currentTurnStartedAt > 0` alone: it persists from the PRIOR turn, so it is
+     *    already > 0 the instant a new task is injected (pre-onTurnStarted).
+     *  - `currentTurnTaskId === meshActiveTaskId` alone: forceSendMessage (the mesh
+     *    inject path) pre-binds currentTurnTaskId to the new taskId at inject time,
+     *    BEFORE the turn starts, so this matches prematurely too.
+     * The robust discriminator is TEMPORAL: the producing turn must have STARTED AFTER
+     * the injection — `currentTurnStartedAt > meshTaskInjectedAt`. Only then has the
+     * injected task's own onTurnStarted fired.
+     *  - No injected task since boot (meshTaskInjectedAt === 0, e.g. an ad-hoc/dashboard
+     *    turn or a non-mesh session): fall back to the plain "a turn has started" check
+     *    so non-mesh completion is unaffected.
+     * Fails CLOSED for the injected-but-not-started window; open once the injected turn is
+     * genuinely underway (preserving the rc.480/481 completion-fires win).
+     */
+    private injectedTaskHasStartedGenerating;
     private meshTraceCtx;
     private completionTraceOn;
     private fsmTraceOn;

package/package.json

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

package/src/mesh/mesh-events-pending.ts

@@ -891,6 +891,39 @@ export function stampPendingEventV2(
     // has no owner to leak from and must reach whatever coordinator drains here.
     const dispatchedBySelfFallback = selfFallback && stamp.scope === 'broadcast';
 
+    // CODA-TERMINAL-EVENT-HELD-WHILE-GENERATING (project-mesh-self-fallback-terminal-
+    // broadcast-drop): an ownerless self-fallback broadcast terminal event
+    // (worktree_bootstrap_complete / refine:completed / a summary-less
+    // agent:generating_completed emitted while THIS machine's coordinator CLI session is
+    // generating) previously carried NO targetCoordinatorDaemonId. The reconcile loop
+    // holds it under `generating_no_idle_coordinator`, and its `event_held` ledger mirror
+    // records targetCoordinatorDaemonId:null — so the held event is not addressable to
+    // the local coordinator's per-daemon scoped file, and (live 2026-07-12) the
+    // coordinator only ever learns of it by polling the ledger, violating the no-polling
+    // rule.
+    //
+    // The event's INTENDED coordinator IS this machine's own coordinator: the
+    // self-fallback minted `dispatchedBy` under this daemon's own machineId precisely
+    // because the originating task was dispatched by this machine's coordinator. Stamp
+    // `targetCoordinatorDaemonId` = that same self daemon id so the held event is
+    // addressable to the local coordinator's scoped file / drain filter, WITHOUT
+    // changing its BROADCAST scope or the `dispatchedBySelfFallback` machine-level
+    // `deliverSelfFallback` guard (which already keeps a replica completion on machine A
+    // from fanning out to a coordinator on machine B). The target is a MACHINE id,
+    // matched by machine core, so it only ever reaches a coordinator on THIS machine.
+    //
+    // Gate: apply ONLY when the event carries NO targetCoordinatorSessionId. A
+    // session-strict event (targetCoordinatorSessionId set, coordinator daemon id
+    // unresolved) is deliberately held/expired by the reconcile loop's strict-route path
+    // keyed on the SESSION, not the daemon — stamping a daemon target there would let it
+    // drain to a sibling before its session returns and break the strict-route hold. An
+    // event that already carries an explicit daemon target is likewise left untouched.
+    const selfFallbackTarget = dispatchedBySelfFallback
+        && !readNonEmptyString(event.targetCoordinatorDaemonId)
+        && !readNonEmptyString(event.targetCoordinatorSessionId)
+        ? readNonEmptyString(stamp.dispatchedBy.daemonId)
+        : undefined;
+
     return {
         ...event,
         protocolVersion: stamp.protocolVersion,
@@ -899,6 +932,7 @@ export function stampPendingEventV2(
         dispatchedBy: stamp.dispatchedBy,
         ...(stamp.intendedFor ? { intendedFor: stamp.intendedFor } : {}),
         ...(dispatchedBySelfFallback ? { dispatchedBySelfFallback: true } : {}),
+        ...(selfFallbackTarget ? { targetCoordinatorDaemonId: selfFallbackTarget } : {}),
     };
 }
 

package/src/mesh/mesh-remote-event-pull.ts

@@ -72,18 +72,26 @@ export async function pullRemoteNodeQueues(
         if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) return;
         if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) return;
 
-        // Peer-connected pre-check (EVENT-DELIVERY-DELAY fix(a)): a degraded peer whose
-        // DataChannel is not open would sink this pull into peer.connectQueue and stall
-        // until CONNECT_TIMEOUT_MS (90s), formerly freezing the whole serial loop and
-        // delaying completion-event recovery from healthy nodes. Skip such a node THIS
-        // tick and retry next tick — LOSSLESS: an unconnected peer has not drained
-        // anything (drained=0 preserved), so its events are recovered whole on the next
-        // successful tick. Skip = delay, never loss.
-        //   • snapshot present and state !== 'connected' → skip (continue next tick).
-        //   • snapshot null/undefined (getter unwired, e.g. standalone) → DO NOT skip;
-        //     fall through to the legacy path so this stays regression-free.
-        const peerSnapshot = components.getMeshPeerConnectionStatus?.(nodeDaemonId);
-        if (peerSnapshot && String(peerSnapshot.state) !== 'connected') return;
+        // Peer-connected pre-check (EVENT-DELIVERY-DELAY fix(a) + OFFLINE-NODE-FANOUT):
+        // a degraded peer whose DataChannel is not open would sink this pull into
+        // peer.connectQueue and stall until CONNECT_TIMEOUT_MS (90s), formerly freezing
+        // the whole serial loop and delaying completion-event recovery from healthy
+        // nodes. Skip such a node THIS tick and retry next tick — LOSSLESS: an
+        // unconnected peer has not drained anything (drained=0 preserved), so its events
+        // are recovered whole on the next successful tick. Skip = delay, never loss.
+        //   • getter WIRED (cloud) → a null/undefined snapshot means "no peer object
+        //     right now" = NOT connected (a powered-off node whose failPeer just deleted
+        //     the peer each cycle). Treat it EXACTLY like state !== 'connected' and skip;
+        //     dialing here would re-queue for another 90s (the null-race the guard is
+        //     meant to prevent). Only a snapshot with state === 'connected' proceeds.
+        //   • getter UNWIRED (standalone) → DO NOT skip; fall through to the legacy path
+        //     so this stays regression-free (the standalone case the guard's history
+        //     references).
+        const getPeerStatus = components.getMeshPeerConnectionStatus;
+        if (getPeerStatus) {
+            const peerSnapshot = getPeerStatus(nodeDaemonId);
+            if (!peerSnapshot || String(peerSnapshot.state) !== 'connected') return;
+        }
 
         for (const pendingEventArgs of pulls) {
             let events: unknown;
@@ -185,15 +193,23 @@ export async function collectLiveNodesWithSessions(
         const isLocalNode = !nodeDaemonId
             || daemonIdListIncludes(selfIds, nodeDaemonId)
             || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
-        // Peer-connected pre-check (EVENT-DELIVERY-DELAY fix(a)): mirror pullRemoteNodeQueues.
-        // Without this the 90s connect-deadline block re-enters via this Promise.all —
-        // a degraded remote's get_status_metadata sinks into peer.connectQueue and stalls
-        // the whole prune probe. Only call the remote when the peer is 'connected'; an
-        // unconnected peer is left undecorated (empty session list), same as unreachable.
-        // Getter unwired (null/undefined) → do NOT skip, fall through (regression-free).
+        // Peer-connected pre-check (EVENT-DELIVERY-DELAY fix(a) + OFFLINE-NODE-FANOUT):
+        // mirror pullRemoteNodeQueues. Without this the 90s connect-deadline block
+        // re-enters via this Promise.all — a degraded remote's get_status_metadata sinks
+        // into peer.connectQueue and stalls the whole prune probe. Only call the remote
+        // when the peer is 'connected'; an unconnected peer is left undecorated (empty
+        // session list), same as unreachable.
+        //   • getter WIRED (cloud) → a null snapshot means "no peer object right now" =
+        //     NOT connected (offline node whose failPeer deleted the peer). Skip (leave
+        //     undecorated) rather than dialing into another 90s connect wait — the same
+        //     null-race harden as pullRemoteNodeQueues.
+        //   • getter UNWIRED (standalone) → do NOT skip, fall through (regression-free).
         if (!isLocalNode) {
-            const peerSnapshot = components.getMeshPeerConnectionStatus?.(nodeDaemonId);
-            if (peerSnapshot && String(peerSnapshot.state) !== 'connected') return node;
+            const getPeerStatus = components.getMeshPeerConnectionStatus;
+            if (getPeerStatus) {
+                const peerSnapshot = getPeerStatus(nodeDaemonId);
+                if (!peerSnapshot || String(peerSnapshot.state) !== 'connected') return node;
+            }
         }
         let statusResult: unknown;
         try {

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

@@ -256,6 +256,15 @@ export class CliProviderInstance implements ProviderInstance {
     // R4b miss: collapse at boot+8s, dispatch at boot+12.4s > the 12s boot window).
     // Anchoring on the collapse moment makes the window cover dispatch-delay+turn.
     private startupGraceCollapseAt: number | null = null;
+    // ANTIGRAVITY-PREMATURE-COMPLETION gate: wall-clock when the CURRENT mesh task
+    // was injected/attached (attachMeshAssignment). The injected task counts as having
+    // genuinely entered generating only once a turn STARTS after this moment
+    // (currentTurnStartedAt > meshTaskInjectedAt) — because currentTurnStartedAt
+    // persists from the PRIOR turn and forceSendMessage pre-binds currentTurnTaskId at
+    // inject time, so neither alone distinguishes "injected but not yet generating"
+    // from "genuinely generating". This timestamp is that discriminator. 0 = no task
+    // injected since boot (ad-hoc/non-mesh turns fall back to the plain turn-started check).
+    private meshTaskInjectedAt = 0;
     private settings: Record<string, any> = {};
     private monitor: StatusMonitor;
     private generatingDebounceTimer: NodeJS.Timeout | null = null;
@@ -862,6 +871,13 @@ export class CliProviderInstance implements ProviderInstance {
      */
     attachMeshAssignment(assignment: { meshId: string; nodeId?: string; taskId?: string; dispatchNonce?: number; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void {
         if (!assignment?.meshId) return;
+        // ANTIGRAVITY-PREMATURE-COMPLETION gate: stamp the injection moment for a task
+        // attach so injectedTaskHasStartedGenerating() can require the producing turn to
+        // START after this point (rejecting the prior turn's stale native-history tail
+        // that would otherwise fire generating_completed before generating_started).
+        if (assignment.taskId && assignment.taskId.trim()) {
+            this.meshTaskInjectedAt = Date.now();
+        }
         this.settings = {
             ...this.settings,
             meshNodeFor: assignment.meshId,
@@ -1468,7 +1484,25 @@ export class CliProviderInstance implements ProviderInstance {
 
         const externalMessages = this.readExternalCompletionMessages();
         if (externalMessages) {
-            const present = turnClosed && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt);
+            // ANTIGRAVITY-PREMATURE-COMPLETION (recur): the external-native transcript is
+            // the WHOLE session's native-history, not turn-scoped by the provider. On a
+            // reused-idle antigravity session, a completion-gate poll can run AFTER a new
+            // task is injected but BEFORE that task's onTurnStarted fires. The transcript
+            // then still tails the PRIOR turn's final-assistant bubble; completionHasFinal‑
+            // AssistantMessage accepts it (turnStartedAt is 0/undefined pre-onTurnStarted →
+            // fails open, or the prior bubble post-dates the prior turn → passes) and a
+            // generating_completed fires for the NEW task BEFORE generating_started — the
+            // exact live 06:34→06:35 inversion. Gate external-native evidence on the current
+            // injected task having genuinely entered generating: if a task is attached but its
+            // turn has not started (turnStartedInjectedTask() === false), the tail is stale by
+            // construction, so this evidence must NOT satisfy the completion gate. Fail CLOSED
+            // (present=false) rather than open. This does NOT regress the rc.480/481 win: once
+            // the injected task's onTurnStarted fires, currentTurnStartedAt/currentTurnTaskId
+            // bind to it and a real final bubble still fires completion normally.
+            const injectedTaskGenerating = this.injectedTaskHasStartedGenerating();
+            const present = injectedTaskGenerating
+                && turnClosed
+                && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt);
             // Dashboard tail-repair cache: this runs on EVERY completion check
             // (mesh AND non-mesh — the non-mesh path suppresses the
             // generating_completed emit, so completionFinalSummary never runs there
@@ -1924,6 +1958,43 @@ export class CliProviderInstance implements ProviderInstance {
         return typeof scalar === 'string' && scalar.trim() ? scalar : undefined;
     }
 
+    /**
+     * ANTIGRAVITY-PREMATURE-COMPLETION gate: has the CURRENTLY-injected task actually
+     * entered generating (a real onTurnStarted for it)? Used to reject stale external-
+     * native completion evidence that predates the injected task's turn.
+     *
+     * The injected task's id is the session scalar `meshActiveTaskId`, stamped by
+     * attachMeshAssignment BEFORE the PTY turn starts. That stamp also records
+     * `meshTaskInjectedAt`. The turn that has genuinely started is marked by
+     * `adapter.currentTurnStartedAt` (set ONLY by onTurnStarted). Two naive signals both
+     * FAIL for a reused-idle session:
+     *  - `currentTurnStartedAt > 0` alone: it persists from the PRIOR turn, so it is
+     *    already > 0 the instant a new task is injected (pre-onTurnStarted).
+     *  - `currentTurnTaskId === meshActiveTaskId` alone: forceSendMessage (the mesh
+     *    inject path) pre-binds currentTurnTaskId to the new taskId at inject time,
+     *    BEFORE the turn starts, so this matches prematurely too.
+     * The robust discriminator is TEMPORAL: the producing turn must have STARTED AFTER
+     * the injection — `currentTurnStartedAt > meshTaskInjectedAt`. Only then has the
+     * injected task's own onTurnStarted fired.
+     *  - No injected task since boot (meshTaskInjectedAt === 0, e.g. an ad-hoc/dashboard
+     *    turn or a non-mesh session): fall back to the plain "a turn has started" check
+     *    so non-mesh completion is unaffected.
+     * Fails CLOSED for the injected-but-not-started window; open once the injected turn is
+     * genuinely underway (preserving the rc.480/481 completion-fires win).
+     */
+    private injectedTaskHasStartedGenerating(): boolean {
+        const turnStartedAt = typeof (this.adapter as any)?.currentTurnStartedAt === 'number'
+            ? (this.adapter as any).currentTurnStartedAt as number
+            : 0;
+        const turnStarted = Number.isFinite(turnStartedAt) && turnStartedAt > 0;
+        if (this.meshTaskInjectedAt <= 0) {
+            // No mesh task injected since boot — plain "a turn has started" suffices.
+            return turnStarted;
+        }
+        // A task was injected: the producing turn must have STARTED after that injection.
+        return turnStarted && turnStartedAt > this.meshTaskInjectedAt;
+    }
+
     // EVTTRACE correlation context for this session's completion lifecycle. taskId is
     // the primary grep anchor; instanceId is the session fallback.
     private meshTraceCtx(event = 'agent:generating_completed'): Record<string, unknown> {