@adhdev/daemon-core 0.9.82-rc.405 → 0.9.82-rc.407

package/package.json

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

package/src/cli-adapters/cli-state-engine.ts

@@ -111,6 +111,13 @@ export class CliStateEngine {
     // queued in pendingOutbound and only flushed asynchronously after idle), so the
     // completion event carries the correct id instead of the racy session scalar.
     currentTurnTaskId: string | null = null;
+    // GENERATING-BOUNDARY (R4d): wall-clock when the most recently STARTED turn began
+    // (set by onTurnStarted, persists past completion until the next turn starts).
+    // The startup-grace idle-stayed synthesis anchors its window on when the FIRST turn
+    // STARTED — not on when it finished — so a turn dispatched a few seconds after the
+    // grace collapse and then running for a non-trivial duration is still attributed to
+    // the startup collapse even though its COMPLETION lands past a now-anchored window.
+    currentTurnStartedAt = 0;
     activeModal: { message: string; buttons: string[] } | null = null;
 
     // ── Approval ─────────────────────────────────────
@@ -247,6 +254,9 @@ export class CliStateEngine {
         this.currentTurnTaskId = typeof turnScope.taskId === 'string' && turnScope.taskId.trim()
             ? turnScope.taskId
             : null;
+        // R4d: stamp the turn-start moment so the startup-grace idle-stayed synthesis can
+        // anchor its window on dispatch time rather than completion time.
+        this.currentTurnStartedAt = Date.now();
         this.responseEpoch += 1;
     }
 

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

@@ -1988,6 +1988,11 @@ export class ProviderCliAdapter implements CliAdapter {
     // reads this when stamping completion events so they carry the completing turn's
     // task rather than the racy last-write-wins session scalar.
     get currentTurnTaskId(): string | null { return this.engine.currentTurnTaskId; }
+    // R4d: wall-clock when the most recently started turn began (persists past settle).
+    // The provider instance's startup-grace idle-stayed synthesis anchors its window on
+    // this so a delayed-dispatch first turn whose duration overruns the now-anchored
+    // window is still attributed to the startup collapse.
+    get currentTurnStartedAt(): number { return this.engine.currentTurnStartedAt; }
 
     get responseEpoch(): number { return this.engine.responseEpoch; }
     set responseEpoch(v: number) { this.engine.responseEpoch = v; }

package/src/mesh/mesh-reconcile-loop.ts

@@ -115,7 +115,40 @@ function resolveReconcileIntervalMs(): number {
 // Keyed by `${meshId}::${taskId}`. The map is pruned each PHASE-4 pass to the set of currently
 // active dispatches, so a completed/pruned task's counter is dropped (no unbounded growth).
 const REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH = 2;
-const inFlightIdleObservationCounts = new Map<string, number>();
+
+// R4e (RECONCILE-SYNTH-PREEMPTS-COMPLETION, time hardening). The consecutive-tick guard above is a
+// tick COUNT; at the 4s cadence it spans only ~8s, which a long worker turn can straddle with a
+// mid-turn idle window (a CLI PTY inter-tool-call settle, or the final assistant text already
+// rendered while the turn's generating_completed lifecycle close still lags). The worker's 5s
+// generating heartbeat means an ~8s idle window is barely over one heartbeat gap, so the tick count
+// alone let a 53s-turn synth fire ~11s BEFORE the worker's real completion emit (R4e live case). We
+// add two TIME hurdles the tick-count cannot express, BOTH finite so a truly-dead worker that never
+// emits is still eventually synthesized (notification-miss stays 0 — only DEFERRED, never dropped):
+//   - MIN_IDLE_SETTLE_MS: the worker must have read idle for at least this long since its FIRST idle
+//     observation. Comfortably exceeds the 5s heartbeat gap so a transient mid-turn idle window
+//     cannot satisfy it; a genuinely-settled or dead session keeps reading idle and crosses it.
+//   - ACKED_TURN_SETTLE_MS: an `acked` (generating_started) dispatch is never synthesized within
+//     this window of its ack (dispatch.updatedAt = the generating_started status flip), so a turn
+//     that only just started is never completed off an early idle blip.
+// Both are read at call time (not module-const) so tests can tune them via env per case.
+function resolveTunedReconcileMs(envName: string, def: number, min: number, max: number): number {
+    const raw = readNonEmptyString(process.env[envName]);
+    if (raw) {
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isFinite(parsed) && parsed >= min && parsed <= max) return parsed;
+    }
+    return def;
+}
+function resolveMinIdleSettleMs(): number {
+    return resolveTunedReconcileMs('MESH_INFLIGHT_MIN_IDLE_SETTLE_MS', 16_000, 0, 120_000);
+}
+function resolveAckedTurnSettleMs(): number {
+    return resolveTunedReconcileMs('MESH_INFLIGHT_ACKED_TURN_SETTLE_MS', 20_000, 0, 180_000);
+}
+
+// Per-task in-flight idle debounce: the consecutive idle-read `count` AND the timestamp of the
+// FIRST idle observation `firstIdleAtMs` (for the MIN_IDLE_SETTLE_MS hurdle).
+const inFlightIdleObservationCounts = new Map<string, { count: number; firstIdleAtMs: number }>();
 
 function inFlightSynthKey(meshId: string, taskId: string): string {
     return `${meshId}::${taskId}`;
@@ -1231,6 +1264,50 @@ function readChatPayloadStatus(payload: Record<string, unknown> | null): string
     return readNonEmptyString(payload?.status).toLowerCase();
 }
 
+// R4e fix (3): peek the pending-events queue for a REAL (worker-emitted) terminal completion
+// already queued for a task — used to yield the in-flight synth to the worker's own emit. Broad
+// peek (no daemon-id scoping) matched precisely by taskId, so a worker stamp in any daemon-id form
+// is still recognized. Best-effort: a peek failure returns false (proceed to synth — never block
+// delivery). A prior SYNTH's still-queued pending event also names this taskId, but a synth always
+// writes its terminal ledger atomically, so hasTerminalLedgerAfterDispatch downstream already
+// no-ops that case — this guard is specifically for an as-yet-unledgered worker emit in flight.
+function realTerminalEmitPendingForTask(meshId: string, taskId: string): boolean {
+    let pending: readonly PendingMeshCoordinatorEvent[];
+    try {
+        pending = getPendingMeshCoordinatorEvents(meshId);
+    } catch {
+        return false;
+    }
+    return pending.some(e =>
+        readNonEmptyString(e.metadataEvent?.taskId) === taskId
+        && (e.event === 'agent:generating_completed' || e.event === 'agent:stopped'));
+}
+
+// R4e fix (2): one fresh read_chat status read for the worker session, via the same local/remote
+// transport PHASE 4 uses. Returns the lowercased status, or null when the read is inconclusive
+// (transport error, success:false, no payload) — callers treat null as "no new evidence, proceed".
+async function reprobeWorkerStatus(
+    components: DaemonComponents,
+    args: { isLocalNode: boolean; nodeDaemonId: string; readArgs: Record<string, unknown> },
+): Promise<string | null> {
+    try {
+        if (args.isLocalNode) {
+            const r = await components.commandHandler.handle('read_chat', args.readArgs);
+            if (r && (r as { success?: boolean }).success === false) return null;
+            return readChatPayloadStatus(unwrapReadChatPayload(r));
+        }
+        if (components.dispatchMeshCommand) {
+            const r = await components.dispatchMeshCommand(args.nodeDaemonId, 'read_chat', args.readArgs);
+            const p = unwrapReadChatPayload(r);
+            if (p && (p as { success?: boolean }).success === false) return null;
+            return readChatPayloadStatus(p);
+        }
+    } catch {
+        return null;
+    }
+    return null;
+}
+
 // PHASE 4 helper. For every active (non-terminal) direct dispatch this daemon
 // hosts, confirm the worker session is idle via a read_chat and — if a final
 // assistant summary is present but no terminal ledger exists for that dispatch —
@@ -1314,6 +1391,7 @@ async function reconcileUnterminatedDirectDispatches(
         // waiting_approval session is mid-turn — synthesizing a completion now would
         // be wrong. (idle is the only status the MCP poll path reconciles too.)
         const synthKey = inFlightSynthKey(mesh.id, taskId);
+        const nowMs = Date.now();
         if (readChatPayloadStatus(payload) !== 'idle') {
             // Not idle → the worker is mid-turn. Reset any partial idle streak so a single
             // idle blip during a long generation never accumulates toward the synth threshold.
@@ -1321,24 +1399,48 @@ async function reconcileUnterminatedDirectDispatches(
             continue;
         }
 
-        // RECONCILE-SYNTH-PREEMPTS-COMPLETION: a dispatch whose worker was OBSERVED to start
-        // generating (the agent:generating_started ack flipped the row to 'acked') and has no
-        // terminal yet is potentially still in-flight — its `idle` read here may be a transient
-        // mid-turn flicker, not a settled completion. Require CONSECUTIVE idle observations
-        // before synthesizing for such a task: a flicker clears next tick (counter reset above),
-        // while a genuinely-settled (completed-but-lost) or dead session reads idle every tick
-        // and crosses the threshold within ~one extra interval. A never-acked dispatch (worker
-        // never started) is exempt — there is no in-flight generation to pre-empt, and its
-        // lost-dispatch case is still covered by the downstream grace + stale-summary guards.
+        // RECONCILE-SYNTH-PREEMPTS-COMPLETION (R4e hardened): a dispatch whose worker was OBSERVED
+        // to start generating (the agent:generating_started ack flipped the row to 'acked') and has
+        // no terminal yet is potentially still in-flight — its `idle` read here may be a transient
+        // mid-turn window, not a settled completion. Before synthesizing for such a task we require
+        // ALL of: (1) CONSECUTIVE idle observations (a flicker clears next tick, counter reset
+        // above); (2) at least MIN_IDLE_SETTLE_MS elapsed since the FIRST idle observation (the time
+        // hurdle the ~8s tick count cannot express — it would otherwise be straddled by a long
+        // turn's mid-turn idle); and (3) at least ACKED_TURN_SETTLE_MS since the generating_started
+        // ack, so a turn that only just started is never completed off an early idle blip. A
+        // genuinely-settled (completed-but-lost) or dead session keeps reading idle and clears all
+        // three within a few extra ticks, so notification-miss stays 0. A never-acked dispatch
+        // (worker never started) is exempt — no in-flight generation to pre-empt; its lost-dispatch
+        // case is covered by the downstream grace + stale-summary guards.
         if (dispatch.status === 'acked') {
-            const idleStreak = (inFlightIdleObservationCounts.get(synthKey) ?? 0) + 1;
-            inFlightIdleObservationCounts.set(synthKey, idleStreak);
-            if (idleStreak < REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH) {
-                LOG.info('MeshReconcile', `In-flight synth hold: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle ${idleStreak}/${REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH} consecutive tick(s) after generating_started — deferring completion synth until the idle settle is confirmed (guards against a mid-turn idle flicker pre-empting the real completion)`);
+            const prior = inFlightIdleObservationCounts.get(synthKey);
+            const firstIdleAtMs = prior?.firstIdleAtMs ?? nowMs;
+            const idleStreak = (prior?.count ?? 0) + 1;
+            inFlightIdleObservationCounts.set(synthKey, { count: idleStreak, firstIdleAtMs });
+            const idleSettleMs = nowMs - firstIdleAtMs;
+            const minIdleSettleMs = resolveMinIdleSettleMs();
+            const ackedTurnSettleMs = resolveAckedTurnSettleMs();
+            const ackedAtMs = Date.parse(readNonEmptyString(dispatch.updatedAt));
+            const sinceAckMs = Number.isFinite(ackedAtMs) ? nowMs - ackedAtMs : Number.POSITIVE_INFINITY;
+            const tickGuardMet = idleStreak >= REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH;
+            const settleGuardMet = idleSettleMs >= minIdleSettleMs;
+            const ackGuardMet = sinceAckMs >= ackedTurnSettleMs;
+            if (!tickGuardMet || !settleGuardMet || !ackGuardMet) {
+                LOG.info('MeshReconcile', `In-flight synth hold: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) idle ${idleStreak}/${REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH} tick(s), settle ${Math.round(idleSettleMs / 1000)}s/${Math.round(minIdleSettleMs / 1000)}s, since-ack ${Number.isFinite(sinceAckMs) ? Math.round(sinceAckMs / 1000) + 's' : '∞'}/${Math.round(ackedTurnSettleMs / 1000)}s — deferring completion synth until the worker's turn genuinely settles (guards against a mid-turn idle window pre-empting the real completion)`);
                 continue;
             }
         }
 
+        // R4e fix (3) — worker-emit priority. If the worker's REAL terminal emit for this task has
+        // already arrived in the pending-events queue (queued for delivery to the coordinator) but
+        // not yet written a terminal ledger, YIELD: let the genuine emit surface rather than racing
+        // it with a synth that would win the taskId-anchored fingerprint dedup and mask it.
+        if (realTerminalEmitPendingForTask(mesh.id, taskId)) {
+            inFlightIdleObservationCounts.delete(synthKey);
+            LOG.info('MeshReconcile', `Worker-emit priority: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) has a real terminal completion already queued — yielding synth to the worker's own emit`);
+            continue;
+        }
+
         const messages = Array.isArray(payload.messages) ? payload.messages as ChatMessage[] : [];
         const evidence = extractFinalAssistantSummaryEvidence(messages);
         if (!evidence.finalSummary) continue; // no assistant result yet — nothing to attribute
@@ -1369,6 +1471,19 @@ async function reconcileUnterminatedDirectDispatches(
             continue;
         }
 
+        // R4e fix (2) — live re-probe immediately before committing the synth. The idle
+        // observations that satisfied the settle guards above accumulated over PRIOR ticks; do one
+        // fresh read right now so a worker that resumed generating since this tick's first read is
+        // never falsely completed off a stale snapshot. Best-effort: an inconclusive re-probe
+        // (transport error/null) falls through to the synth — we already hold a valid idle read from
+        // the top of THIS tick, so a re-probe failure must not re-introduce a notification-miss.
+        const reprobeStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
+        if (reprobeStatus && reprobeStatus !== 'idle') {
+            inFlightIdleObservationCounts.delete(synthKey);
+            LOG.info('MeshReconcile', `Live re-probe defer: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read '${reprobeStatus}' at synth-commit time — worker resumed generating; deferring synth to a later tick`);
+            continue;
+        }
+
         const providerSessionId = readNonEmptyString(payload.providerSessionId);
         const coordinatorDaemonId = selfIds.find(id => !!id);
         try {

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

@@ -148,7 +148,9 @@ const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60_000;
 // before collapsing to idle; a turn can be dispatched a few seconds AFTER that collapse
 // (the live R4b miss: collapse at boot+8s, dispatch at boot+12.4s — already past a 12s
 // boot-anchored window before the turn even started). Anchoring on the collapse moment
-// makes the window cover dispatch-delay + turn-duration. The strong discriminator is
+// covers dispatch-delay; R4d additionally anchors on the turn-START moment
+// (engine.currentTurnStartedAt) so a non-trivial turn-DURATION cannot push the completion
+// past a now-anchored window (the live rc.405 Probe2 miss). The strong discriminator is
 // generatingStartedAt===0 (generating was never observed) AND a started-but-finished turn
 // — the window only keeps the synthesized reason honest and scopes the synthesis to the
 // boot collapse, so a much-later unobservably-fast turn is not mislabelled a startup collapse.
@@ -2468,11 +2470,35 @@ export class CliProviderInstance implements ProviderInstance {
         // idle. Normal turns that DO reach 'busy' set generatingStartedAt and are
         // excluded; a queued-pending first turn that only runs after grace falls
         // outside the window and completes normally via idle→busy→idle.
+        //
+        // R4d (the live rc.405 Probe2 miss): R4c anchored the window on the collapse
+        // moment but still measured its END against `now` (the poll/completion time). The
+        // helper only fires once the turn has FINISHED (!hasAdapterPendingResponse()), so
+        // the first eligible poll happens at completion. When the first turn is dispatched
+        // a few seconds after the collapse AND runs for a non-trivial duration, that
+        // completion lands PAST the 12s now-anchored window even though the turn was a
+        // genuine startup-grace first turn (live: collapse→dispatch +5.2s, turn ~11s →
+        // completion at collapse+16.2s > 12s). Anchor the window on when the first turn
+        // STARTED (engine.currentTurnStartedAt, set by onTurnStarted) instead: a turn that
+        // STARTED within the collapse window is a startup-grace first turn no matter how
+        // long it then ran. The now-anchored check is retained as a union so a fast turn
+        // (dispatched+completed quickly within 12s of collapse) keeps firing too; both
+        // close for a much-later turn, preserving the "don't mislabel a late fast turn"
+        // honesty the window exists for.
+        const firstTurnStartedAt = typeof (this.adapter as any)?.currentTurnStartedAt === 'number'
+            ? (this.adapter as any).currentTurnStartedAt as number
+            : 0;
+        const collapsedAt = this.startupGraceCollapseAt;
+        const turnStartedWithinCollapseWindow = collapsedAt !== null
+            && firstTurnStartedAt > 0
+            && firstTurnStartedAt >= collapsedAt
+            && (firstTurnStartedAt - collapsedAt) < STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS;
+        const nowWithinCollapseWindow = collapsedAt !== null
+            && (now - collapsedAt) < STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS;
         if (
             newStatus === 'idle'
             && previousStatus === 'idle'
-            && this.startupGraceCollapseAt !== null
-            && (now - this.startupGraceCollapseAt) < STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS
+            && (turnStartedWithinCollapseWindow || nowWithinCollapseWindow)
         ) {
             this.maybeSynthesizeStartupGraceCollapse(chatTitle, now, 'startup_grace_idle_turn_collapse');
         }