@adhdev/daemon-core 0.9.82-rc.404 → 0.9.82-rc.406

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

@@ -87,6 +87,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private agentReadyEmitted;
     private generatingStartedAt;
     private fastCollapseSynthesizedTaskId;
+    private startupGraceCollapseAt;
     private settings;
     private monitor;
     private generatingDebounceTimer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.404",
+  "version": "0.9.82-rc.406",
   "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.404",
+    "@adhdev/mesh-shared": "0.9.82-rc.406",
     "@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/providers/cli-provider-instance.ts

@@ -140,15 +140,20 @@ const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
 // DUPLICATE_DISPATCH_WINDOW_MS (mesh-tools) so the daemon's bubble-level guard
 // covers the same retry horizon as the MCP-level dispatch dedup.
 const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60_000;
-// GENERATING-BOUNDARY (R4b): age-since-boot window inside which a "first turn that
-// ran+completed without the FSM ever observing a 'generating' frame" is attributed
-// to the startup-grace collapse and synthesized (reason 'startup_grace_idle_turn_collapse').
-// The spec's startup-grace exit is elapsed_ms=8000; a turn dispatched into that window
-// can complete a little after it drains, so the window is the 8s grace plus a settle
-// buffer. 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 boot, so a much-later unobservably-fast turn
-// is not mislabelled a startup collapse.
+// GENERATING-BOUNDARY (R4c): window — measured from the startup-grace COLLAPSE moment
+// (startupGraceCollapseAt), not boot — inside which a "first turn that ran+completed
+// without the FSM ever observing a 'generating' frame" is attributed to the startup-grace
+// collapse and synthesized (reason 'startup_grace_idle_turn_collapse').
+// The spec's startup-grace exit is elapsed_ms=8000, so the FSM spends ~8s in 'starting'
+// 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
+// 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.
 const STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12_000;
 
 /** Events that signal a dispatched mesh task has reached a terminal state.
@@ -481,6 +486,16 @@ export class CliProviderInstance implements ProviderInstance {
     // steadily while the session sits idle, so this guard makes the synthesis fire
     // AT MOST ONCE per collapsed turn.
     private fastCollapseSynthesizedTaskId: string | null = null;
+    // GENERATING-BOUNDARY (R4c): the wall-clock moment the FSM's starting→idle
+    // startup-grace collapse was observed (set ONCE, on the first starting→idle
+    // transition this boot). The idle-stayed collapse window is anchored on THIS,
+    // not on instance/boot time (this.startedAt): the FSM spends the full 8s
+    // startup-grace sitting in 'starting' before collapsing, and a turn can be
+    // dispatched a few seconds AFTER the collapse — measuring the window from boot
+    // would have it already closed by the time that turn lands+completes (the live
+    // 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;
     private settings: Record<string, any> = {};
     private monitor: StatusMonitor;
     private generatingDebounceTimer: NodeJS.Timeout | null = null;
@@ -2382,6 +2397,11 @@ export class CliProviderInstance implements ProviderInstance {
                 }
             } else if (newStatus === 'idle' && this.lastStatus === 'starting') {
                 this.emitAgentReadyOnce(chatTitle, now);
+                // GENERATING-BOUNDARY (R4c): stamp the collapse moment ONCE so the
+                // idle-stayed window below is anchored on the startup-grace collapse,
+                // not on boot. Set only the first time so a later starting re-entry
+                // cannot slide the window forward.
+                if (this.startupGraceCollapseAt === null) this.startupGraceCollapseAt = now;
                 // GENERATING-BOUNDARY fast-collapse (R4, win32 startup-grace first turn):
                 // a turn dispatched into the startup-grace window can START and FINISH while
                 // the FSM is still in 'starting'. On a daemon whose claude-cli spec has NOT yet
@@ -2450,10 +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'
-            && (now - this.startedAt) < STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS
+            && (turnStartedWithinCollapseWindow || nowWithinCollapseWindow)
         ) {
             this.maybeSynthesizeStartupGraceCollapse(chatTitle, now, 'startup_grace_idle_turn_collapse');
         }