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

package/dist/index.mjs

@@ -412,10 +412,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "f8a9c82867f25cbcb7bbfb407d1c3aa98585ff25" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "f8a9c828" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.501" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-12T07:37:10.217Z" : void 0);
+  const commit = readInjected(true ? "697af741759b27253991842eccf35716fbd33205" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "697af741" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.502" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-12T08:56:31.769Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -8945,6 +8945,7 @@ function stampPendingEventV2(event, hint) {
   });
   if (!stamp) return event;
   const dispatchedBySelfFallback = selfFallback && stamp.scope === "broadcast";
+  const selfFallbackTarget = dispatchedBySelfFallback && !readNonEmptyString2(event.targetCoordinatorDaemonId) && !readNonEmptyString2(event.targetCoordinatorSessionId) ? readNonEmptyString2(stamp.dispatchedBy.daemonId) : void 0;
   return {
     ...event,
     protocolVersion: stamp.protocolVersion,
@@ -8952,7 +8953,8 @@ function stampPendingEventV2(event, hint) {
     scope: stamp.scope,
     dispatchedBy: stamp.dispatchedBy,
     ...stamp.intendedFor ? { intendedFor: stamp.intendedFor } : {},
-    ...dispatchedBySelfFallback ? { dispatchedBySelfFallback: true } : {}
+    ...dispatchedBySelfFallback ? { dispatchedBySelfFallback: true } : {},
+    ...selfFallbackTarget ? { targetCoordinatorDaemonId: selfFallbackTarget } : {}
   };
 }
 function readCoordinatorIdentityFromWire(raw) {
@@ -45554,6 +45556,15 @@ var CliProviderInstance = class _CliProviderInstance {
   // 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.
   startupGraceCollapseAt = 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).
+  meshTaskInjectedAt = 0;
   settings = {};
   monitor;
   generatingDebounceTimer = null;
@@ -45968,6 +45979,9 @@ var CliProviderInstance = class _CliProviderInstance {
    */
   attachMeshAssignment(assignment) {
     if (!assignment?.meshId) return;
+    if (assignment.taskId && assignment.taskId.trim()) {
+      this.meshTaskInjectedAt = Date.now();
+    }
     this.settings = {
       ...this.settings,
       meshNodeFor: assignment.meshId,
@@ -46442,7 +46456,8 @@ var CliProviderInstance = class _CliProviderInstance {
     }
     const externalMessages = this.readExternalCompletionMessages();
     if (externalMessages) {
-      const present = turnClosed && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt);
+      const injectedTaskGenerating = this.injectedTaskHasStartedGenerating();
+      const present = injectedTaskGenerating && turnClosed && this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt);
       const lastVisibleAssistant = this.lastVisibleAssistantSummary(externalMessages);
       if (lastVisibleAssistant) {
         this.lastCompletionSummary = { content: lastVisibleAssistant, receivedAt: Date.now() };
@@ -46750,6 +46765,38 @@ var CliProviderInstance = class _CliProviderInstance {
     const scalar = this.settings.meshActiveTaskId;
     return typeof scalar === "string" && scalar.trim() ? scalar : void 0;
   }
+  /**
+   * 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).
+   */
+  injectedTaskHasStartedGenerating() {
+    const turnStartedAt = typeof this.adapter?.currentTurnStartedAt === "number" ? this.adapter.currentTurnStartedAt : 0;
+    const turnStarted = Number.isFinite(turnStartedAt) && turnStartedAt > 0;
+    if (this.meshTaskInjectedAt <= 0) {
+      return turnStarted;
+    }
+    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.
   meshTraceCtx(event = "agent:generating_completed") {