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

package/dist/index.js

@@ -30127,10 +30127,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "4e4b5f468d194f630073a66359898bce97fadf4b" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "4e4b5f46" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.405" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-28T03:55:26.092Z" : void 0);
+      const commit = readInjected(true ? "bfd7d9b1d38a7d1f4709fbad2627c56b5a1ae342" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "bfd7d9b1" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.407" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-28T06:12:42.391Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -46204,6 +46204,20 @@ ${cleanBody}`;
       }
       return DEFAULT_RECONCILE_INTERVAL_MS;
     }
+    function resolveTunedReconcileMs(envName, def, min, max) {
+      const raw = readNonEmptyString2(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() {
+      return resolveTunedReconcileMs("MESH_INFLIGHT_MIN_IDLE_SETTLE_MS", 16e3, 0, 12e4);
+    }
+    function resolveAckedTurnSettleMs() {
+      return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TURN_SETTLE_MS", 2e4, 0, 18e4);
+    }
     function inFlightSynthKey(meshId, taskId) {
       return `${meshId}::${taskId}`;
     }
@@ -46780,6 +46794,33 @@ ${cleanBody}`;
     function readChatPayloadStatus(payload) {
       return readNonEmptyString2(payload?.status).toLowerCase();
     }
+    function realTerminalEmitPendingForTask(meshId, taskId) {
+      let pending;
+      try {
+        pending = getPendingMeshCoordinatorEvents(meshId);
+      } catch {
+        return false;
+      }
+      return pending.some((e) => readNonEmptyString2(e.metadataEvent?.taskId) === taskId && (e.event === "agent:generating_completed" || e.event === "agent:stopped"));
+    }
+    async function reprobeWorkerStatus(components, args) {
+      try {
+        if (args.isLocalNode) {
+          const r = await components.commandHandler.handle("read_chat", args.readArgs);
+          if (r && r.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.success === false) return null;
+          return readChatPayloadStatus(p);
+        }
+      } catch {
+        return null;
+      }
+      return null;
+    }
     async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds, localDaemonId) {
       const dispatches = getActiveDirectDispatches(mesh.id);
       if (dispatches.length === 0) return;
@@ -46827,18 +46868,34 @@ ${cleanBody}`;
         }
         if (!payload) continue;
         const synthKey = inFlightSynthKey(mesh.id, taskId);
+        const nowMs = Date.now();
         if (readChatPayloadStatus(payload) !== "idle") {
           inFlightIdleObservationCounts.delete(synthKey);
           continue;
         }
         if (dispatch.status === "acked") {
-          const idleStreak = (inFlightIdleObservationCounts.get(synthKey) ?? 0) + 1;
-          inFlightIdleObservationCounts.set(synthKey, idleStreak);
-          if (idleStreak < REQUIRED_CONSECUTIVE_IDLE_TICKS_FOR_INFLIGHT_SYNTH) {
-            LOG2.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 \u2014 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(readNonEmptyString2(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) {
+            LOG2.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 / 1e3)}s/${Math.round(minIdleSettleMs / 1e3)}s, since-ack ${Number.isFinite(sinceAckMs) ? Math.round(sinceAckMs / 1e3) + "s" : "\u221E"}/${Math.round(ackedTurnSettleMs / 1e3)}s \u2014 deferring completion synth until the worker's turn genuinely settles (guards against a mid-turn idle window pre-empting the real completion)`);
             continue;
           }
         }
+        if (realTerminalEmitPendingForTask(mesh.id, taskId)) {
+          inFlightIdleObservationCounts.delete(synthKey);
+          LOG2.info("MeshReconcile", `Worker-emit priority: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) has a real terminal completion already queued \u2014 yielding synth to the worker's own emit`);
+          continue;
+        }
         const messages = Array.isArray(payload.messages) ? payload.messages : [];
         const evidence = extractFinalAssistantSummaryEvidence(messages);
         if (!evidence.finalSummary) continue;
@@ -46855,6 +46912,12 @@ ${cleanBody}`;
           }, `transcriptAt=${evidence.transcriptMessageAt} < dispatchedAt=${dispatch.dispatchedAt}`);
           continue;
         }
+        const reprobeStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
+        if (reprobeStatus && reprobeStatus !== "idle") {
+          inFlightIdleObservationCounts.delete(synthKey);
+          LOG2.info("MeshReconcile", `Live re-probe defer: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read '${reprobeStatus}' at synth-commit time \u2014 worker resumed generating; deferring synth to a later tick`);
+          continue;
+        }
         const providerSessionId = readNonEmptyString2(payload.providerSessionId);
         const coordinatorDaemonId = selfIds.find((id) => !!id);
         try {
@@ -49493,6 +49556,13 @@ ${cont}` : cont;
           // queued in pendingOutbound and only flushed asynchronously after idle), so the
           // completion event carries the correct id instead of the racy session scalar.
           currentTurnTaskId = 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 = null;
           // ── Approval ─────────────────────────────────────
           lastApprovalResolvedAt = 0;
@@ -49603,6 +49673,7 @@ ${cont}` : cont;
             this.clearIdleFinishCandidate("send_message");
             this.currentTurnScope = turnScope;
             this.currentTurnTaskId = typeof turnScope.taskId === "string" && turnScope.taskId.trim() ? turnScope.taskId : null;
+            this.currentTurnStartedAt = Date.now();
             this.responseEpoch += 1;
           }
           /** Called when PTY exits */
@@ -52080,6 +52151,13 @@ ${lastSnapshot}`;
           get currentTurnTaskId() {
             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() {
+            return this.engine.currentTurnStartedAt;
+          }
           get responseEpoch() {
             return this.engine.responseEpoch;
           }
@@ -71010,7 +71088,11 @@ ${body}
           }
           this.lastStatus = newStatus;
         }
-        if (newStatus === "idle" && previousStatus === "idle" && this.startupGraceCollapseAt !== null && now - this.startupGraceCollapseAt < STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS) {
+        const firstTurnStartedAt = typeof this.adapter?.currentTurnStartedAt === "number" ? this.adapter.currentTurnStartedAt : 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" && (turnStartedWithinCollapseWindow || nowWithinCollapseWindow)) {
           this.maybeSynthesizeStartupGraceCollapse(chatTitle, now, "startup_grace_idle_turn_collapse");
         }
         if (newStatus === "idle" && adapterStatus.fsmReadySeen === true && !this.agentReadyEmitted) {