@adhdev/daemon-core 0.9.82-rc.484 → 0.9.82-rc.485

package/package.json

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

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

@@ -208,6 +208,13 @@ export class ProviderCliAdapter implements CliAdapter {
     private lastScreenSnapshot = '';
     private lastScreenText = '';
     private lastScreenSnapshotReadAt = Number.NEGATIVE_INFINITY;
+    // (FALSEIDLE Path-C) Count of CONSECUTIVE getStatus polls that observed a
+    // gate-eligible static-idle screen (detect=idle, no modal, quiet, empty
+    // partial buffer). For a mesh/autonomous worker we require several such
+    // polls in a row before confirming static-idle (see getStatus), so a
+    // single momentarily-silent point-sample of a still-live turn cannot flip
+    // it. Reset to 0 the instant any poll is ineligible.
+    private staticIdlePollStreak = 0;
 
  // Server log forwarding
     private serverConn: any = null;
@@ -287,6 +294,13 @@ export class ProviderCliAdapter implements CliAdapter {
         result: any;
     } | null = null;
     private static readonly SCREEN_SNAPSHOT_MIN_INTERVAL_MS = 250;
+    // (FALSEIDLE Path-C) Consecutive gate-eligible getStatus polls a mesh/autonomous
+    // session must show before the poll-static-idle confirm fires. 2 = one extra
+    // status tick of hysteresis: enough to reject a single momentary-silence
+    // point-sample of a still-live turn, cheap enough not to materially delay a
+    // genuine boot-wedge release (the wedge screen is stably static, so it clears
+    // every consecutive poll and confirms on the 2nd).
+    private static readonly STATIC_IDLE_POLL_CONFIRM_COUNT = 2;
 
     private readonly providerResolutionMeta: ProviderResolutionMeta;
 
@@ -394,6 +408,20 @@ export class ProviderCliAdapter implements CliAdapter {
         return this.timeouts.statusActivityHold;
     }
 
+    // (FALSEIDLE Path-C) Whether this session is a mesh worker or coordinator's
+    // own autonomous session. Mirrors CliProviderInstance.isAutonomousMeshSession
+    // over the runtimeSettings the instance mirrors down via updateRuntimeSettings
+    // (meshNodeFor / meshActiveTaskId / meshNodeId / launchedByCoordinator =
+    // isMeshWorkerSession, plus meshCoordinatorFor for the coordinator's own turn).
+    // Such a session has no human at the keyboard to correct a premature idle, so
+    // the poll-static-idle confirm is debounced for it (multiple consecutive idle
+    // polls) rather than fired on a single point-sample.
+    private isAutonomousMeshSession(): boolean {
+        const s = this.runtimeSettings;
+        return !!(s?.meshNodeFor || s?.meshActiveTaskId || s?.meshNodeId
+            || s?.launchedByCoordinator || s?.meshCoordinatorFor);
+    }
+
  // Resolved timeouts
     private readonly timeouts: Required<NonNullable<CliProviderModule['timeouts']>>;
 
@@ -956,15 +984,56 @@ export class ProviderCliAdapter implements CliAdapter {
             const quietForMs = this.lastNonEmptyOutputAt
                 ? (now - this.lastNonEmptyOutputAt)
                 : Number.MAX_SAFE_INTEGER;
+            let eligible = false;
             if (quietForMs >= this.getStatusActivityHoldMs()) {
                 const screenText = this.terminalScreen.getText();
                 const pollDetect = this.runDetectStatus(screenText || this.recentOutputBuffer);
                 const pollModal = this.runParseApproval(screenText)
                     || this.runParseApproval(this.recentOutputBuffer);
-                if (pollDetect === 'idle' && !pollModal) {
+                // (FALSEIDLE Path-C) Final-assistant / pending-response discriminator.
+                // Paths A and B refuse to finalize a turn whose partial-response buffer
+                // is still non-empty (getCompletedFinalizationBlock 'partial_response_pending'
+                // / completionFinalAssistantEvidence turnClosed at cli-provider-instance.ts).
+                // Path C (this poll) previously OMITTED it, so a genuinely-live but
+                // momentarily-silent turn — silent thinking, a backgrounded/long tool child,
+                // the gap between two assistant bubbles — whose currentTurnScope anchor was
+                // lost still satisfied the weaker gate and flipped to idle prematurely.
+                // Require an EMPTY partial buffer here too. getPartialResponse() returns the
+                // accumulated assistant stream while isWaitingForResponse (which
+                // applyGenerating leaves set on the boot-banner wedge too), so this does NOT
+                // reintroduce the D4b wedge: the attach/boot-banner seeds only the static
+                // ready screen — no assistant turn ever streamed — so its partial buffer is
+                // empty and the gate still releases it. A mid-turn quiet gap holds a
+                // non-empty buffer and is deferred.
+                const partial = this.getPartialResponse();
+                const partialPending = typeof partial === 'string' && partial.trim().length > 0;
+                eligible = pollDetect === 'idle' && !pollModal && !partialPending;
+            }
+            if (eligible) {
+                // (FALSEIDLE Path-C) Debounce for autonomous mesh sessions. A worker /
+                // coordinator has no human to correct a premature idle, and a single
+                // runDetectStatus point-sample can land in a live turn's momentary silence.
+                // Require STATIC_IDLE_POLL_CONFIRM_COUNT consecutive eligible polls before
+                // confirming, so the FSM must observe a sustained static-idle screen — a
+                // turn that resumes (fresh output, or a re-armed turn scope) resets the
+                // streak. The status poll runs on the 30s-idle / 5s-generating heartbeat and
+                // this getStatus gate is re-hit each dashboard status tick, so 2 confirms is
+                // ~one extra tick of hysteresis — enough to reject a one-sample silence gap
+                // without materially delaying a genuine boot-wedge release. Foreground /
+                // attended sessions keep the single-poll confirm (a human is watching Send).
+                const requiredStreak = this.isAutonomousMeshSession()
+                    ? ProviderCliAdapter.STATIC_IDLE_POLL_CONFIRM_COUNT
+                    : 1;
+                this.staticIdlePollStreak += 1;
+                if (this.staticIdlePollStreak >= requiredStreak) {
                     this.engine.confirmPollStaticIdle('poll_static_idle');
+                    this.staticIdlePollStreak = 0;
                 }
+            } else {
+                this.staticIdlePollStreak = 0;
             }
+        } else {
+            this.staticIdlePollStreak = 0;
         }
         let effectiveStatus = this.projectEffectiveStatus(startupModal);
         let effectiveModal = startupModal || this.engine.activeModal;

package/src/mesh/mesh-queue-assignment.ts

@@ -92,12 +92,62 @@ export function getMeshWithCache(components: DaemonComponents, meshId: string):
  * worktree node therefore read a permanently stale 'running' here, so
  * shouldDeferDispatchForBootstrap deferred its claim forever. We now MERGE the inline
  * cache's dynamic runtime bootstrap state onto the config node (config keeps its static
- * fields; worktreeBootstrap is preferred from the inline cache when the inline entry
- * carries a status) so the gate view sees the terminal stamp. Regression-safe: when the
- * inline entry has no bootstrap status the config value is kept, and when bootstrap is
- * genuinely still 'running' (no terminal stamp yet) the gate still defers — only a node
- * whose inline stamp has actually reached a terminal state opens the gate.
+ * fields; worktreeBootstrap is preferred from the inline cache) so EVERY consumer of the
+ * merged view — not just tryAssignQueueTask's gate — observes the terminal stamp.
+ *
+ * RESIDUAL-getMeshWithCache-bootstrap-overlay (precedence guard): the overlay is DIRECTIONAL —
+ * it prefers the inline entry ONLY when the inline runtime state is actually fresher, never
+ * merely because the inline entry carries a status. inlineBootstrapIsFresher() (below) permits
+ * the overlay in exactly two cases, mirroring the mission's "terminal OR strictly newer" rule:
+ *   (1) the inline state is TERMINAL ('complete'/'failed') while the config state is NOT — the
+ *       markWorktreeBootstrapTerminalState synchronous stamp the async config persist has not
+ *       yet caught up to; this is the whole point of the overlay (opens the gate).
+ *   (2) both states are non-terminal but the inline startedAt is STRICTLY newer — a re-driven
+ *       bootstrap whose fresher 'running' epoch the config has not observed.
+ * It REFUSES the overlay when the config state is already terminal and the inline state is a
+ * stale/non-terminal 'running' — otherwise a stale inline 'running' would MASK a genuinely
+ * complete config node and re-defer its claim forever (the exact anti-case this guard closes).
+ * And when both are 'running' with no newer epoch, the config value is kept and the gate still
+ * defers — the half-built-worktree → empty-session defense is preserved: only a terminal-confirmed
+ * inline state, never an ambiguous read, ever opens the gate.
  */
+const BOOTSTRAP_TERMINAL_STATUSES = new Set(['complete', 'failed']);
+
+function bootstrapEpochMs(bootstrap: any): number {
+    const raw = readNonEmptyString(bootstrap?.startedAt) || readNonEmptyString(bootstrap?.completedAt);
+    if (!raw) return 0;
+    const parsed = Date.parse(raw);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+
+/**
+ * Directional freshness test for the bootstrap overlay: may the inline runtime state
+ * REPLACE the config runtime state? True only when the inline state is terminal and the
+ * config state is not (the synchronous terminal stamp the async persist lags), or when
+ * both are non-terminal but the inline epoch is strictly newer. A terminal config state is
+ * never overwritten by a non-terminal inline read (the stale-'running'-masks-complete
+ * anti-case), and equal states never trigger a rewrite.
+ */
+function inlineBootstrapIsFresher(inlineBootstrap: any, configBootstrap: any): boolean {
+    const inlineStatus = readNonEmptyString(inlineBootstrap?.status);
+    if (!inlineStatus) return false;
+    const configStatus = readNonEmptyString(configBootstrap?.status);
+    const inlineTerminal = BOOTSTRAP_TERMINAL_STATUSES.has(inlineStatus);
+    const configTerminal = !!configStatus && BOOTSTRAP_TERMINAL_STATUSES.has(configStatus);
+    // Config already terminal: only a DIFFERENT terminal inline state (e.g. config 'complete'
+    // vs a later 'failed' re-drive) may supersede it; a non-terminal inline read must never
+    // mask a terminal config state.
+    if (configTerminal) {
+        return inlineTerminal && inlineStatus !== configStatus
+            && bootstrapEpochMs(inlineBootstrap) > bootstrapEpochMs(configBootstrap);
+    }
+    // Config not terminal: an inline terminal state is always fresher (opens the gate).
+    if (inlineTerminal) return true;
+    // Both non-terminal: prefer inline only when its epoch is strictly newer (a re-driven
+    // bootstrap the config has not observed). Equal/older ⇒ keep config, gate still defers.
+    return bootstrapEpochMs(inlineBootstrap) > bootstrapEpochMs(configBootstrap);
+}
+
 function mergeInlineCacheOnlyNodes(localMesh: any, cachedMesh: any): any {
     const localNodes = Array.isArray(localMesh?.nodes) ? localMesh.nodes : [];
     const cachedNodes = Array.isArray(cachedMesh?.nodes) ? cachedMesh.nodes : [];
@@ -111,10 +161,10 @@ function mergeInlineCacheOnlyNodes(localMesh: any, cachedMesh: any): any {
         if (!cachedId) return false;
         return !localNodes.some((localNode: any) => meshNodeIdMatches(localNode, cachedId));
     });
-    // Overlay the inline cache's fresher worktreeBootstrap state onto any config node
-    // that also exists in the inline cache. Only override when the inline entry actually
-    // carries a bootstrap status (an incomplete inline entry never masks a genuine config
-    // 'running'), mirroring the inline-first read the bootstrap gate does directly.
+    // Overlay the inline cache's fresher worktreeBootstrap state onto any config node that
+    // also exists in the inline cache. inlineBootstrapIsFresher() gates the overlay to the
+    // "terminal OR strictly newer" cases, so a stale inline 'running' can never mask a
+    // terminal config state and the gate's deferral is preserved for a genuine 'running'.
     let overlaidLocalNodes: any[] = localNodes;
     let overlaid = false;
     for (let i = 0; i < localNodes.length; i++) {
@@ -122,14 +172,14 @@ function mergeInlineCacheOnlyNodes(localMesh: any, cachedMesh: any): any {
         const localId = readMeshNodeId(localNode);
         if (!localId) continue;
         const inlineMatch = cachedNodes.find((cachedNode: any) => meshNodeIdMatches(cachedNode, localId));
-        const inlineBootstrapStatus = readNonEmptyString(inlineMatch?.worktreeBootstrap?.status);
-        if (!inlineMatch || !inlineBootstrapStatus) continue;
+        if (!inlineMatch) continue;
+        if (!inlineBootstrapIsFresher(inlineMatch.worktreeBootstrap, localNode.worktreeBootstrap)) continue;
         if (!overlaid) {
             overlaidLocalNodes = [...localNodes];
             overlaid = true;
         }
-        // Keep the config node's static fields; prefer the inline cache's dynamic
-        // bootstrap runtime state (fresher terminal stamp).
+        // Keep the config node's static fields; overlay only the dynamic worktreeBootstrap
+        // runtime substate (fresher terminal stamp / epoch) — config identity is unchanged.
         overlaidLocalNodes[i] = { ...localNode, worktreeBootstrap: inlineMatch.worktreeBootstrap };
     }
     if (!cacheOnly.length && !overlaid) return localMesh;