@adhdev/daemon-standalone 1.0.28-rc.32 → 1.0.28-rc.33

package/dist/index.js

@@ -33311,10 +33311,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "9d291b6668878c1d0e3c210fad52ff57cf9ec1f8" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "9d291b66" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28-rc.32" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-30T17:15:53.842Z" : void 0);
+      const commit = readInjected(true ? "5e05ac37dcef7e88d50d419fe2cf93bfbf77fc88" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "5e05ac37" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.28-rc.33" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-31T00:24:14.883Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -39597,6 +39597,32 @@ Next step: ${nextStep}`;
         return false;
       }
     }
+    function requeueDrainedPendingMeshCoordinatorEvent(event) {
+      const fingerprint = buildPendingEventFingerprint(event);
+      if (!fingerprint.trim()) return false;
+      let requeued = false;
+      try {
+        requeued = MeshRuntimeStore.getInstance().requeueDrainedPendingEventByFingerprint(event.meshId, fingerprint);
+      } catch (e) {
+        LOG2.warn("MeshEvents", `SQLite re-queue of held ${event.event} failed for mesh ${event.meshId}: ${e?.message || e}`);
+      }
+      try {
+        const path50 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
+        const alreadyOnDisk = readPendingMeshCoordinatorEventsFromDisk(event.meshId, event.targetCoordinatorDaemonId).some((pending) => buildPendingEventFingerprint(pending) === fingerprint);
+        if (!alreadyOnDisk) {
+          trimPendingEventsIfNeeded(path50);
+          (0, import_fs5.appendFileSync)(path50, JSON.stringify(event) + "\n", "utf-8");
+          requeued = true;
+        }
+      } catch (e) {
+        if (!requeued) {
+          LOG2.warn("MeshEvents", `Failed to durably re-queue held ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
+          return false;
+        }
+        LOG2.warn("MeshEvents", `JSONL re-queue append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
+      }
+      return requeued;
+    }
     function atomicDrainFile(path50) {
       const tmpPath = `${path50}.draining`;
       try {
@@ -43395,6 +43421,49 @@ Next step: ${nextStep}`;
               `UPDATE mesh_pending_events SET drained = 1, drained_at = ? WHERE drained = 0 AND id IN (${idList.map(() => "?").join(",")})`
             ).run(now, ...idList).changes;
           }
+          /**
+           * STRICT-ROUTE-HOLD-DURABILITY: return an ALREADY-DRAINED row to the queue
+           * (drained=1 → drained=0), in place, by fingerprint.
+           *
+           * Why this exists (the rc.33 defect): a strict-routed completion whose originating
+           * coordinator session is not currently live is "held" by re-queuing it. That
+           * re-queue used to call the normal insert path, which CANNOT work for a held
+           * event — three independent suppressors reject it:
+           *
+           *   1. `idx_mesh_pending_events_fingerprint` is UNIQUE on (mesh_id, fingerprint)
+           *      with NO `drained` qualifier, and insertPendingEvent uses INSERT OR IGNORE.
+           *      The just-drained row still occupies that fingerprint, so the "fresh
+           *      undrained copy" is silently ignored — changes = 0, no row added.
+           *   2. hasPendingCoordinatorEventDuplicate → hasPendingEventFingerprint queries
+           *      `drained = 0`, so it does NOT see the drained original and reports no
+           *      duplicate — the caller believes the re-queue succeeded.
+           *   3. Even if a copy did land, the v2 eventId is already in
+           *      drainedEventIdsForMesh(), so routeV2EventsForDrainer would skip it as
+           *      already-delivered on the next drain.
+           *
+           * The pre-restart hold only ever worked because the in-memory reconcile loop
+           * re-read the event; nothing durable was written. A restart inside the 60s TTL
+           * therefore lost the completion permanently (observed: task ec6c901a — exactly
+           * one row, drained=1, and zero lines in the JSONL mirror).
+           *
+           * Flipping the EXISTING row back to drained=0 is the only correct move: it keeps
+           * the unique fingerprint (no duplicate row can ever be created), removes the
+           * eventId from the drained-baseline so the v2 idempotency filter stops swallowing
+           * it, and makes the hold survive a process restart. queued_at is deliberately
+           * PRESERVED so the strict TTL keeps measuring the event's true age across holds
+           * and cannot be refreshed into an immortal row.
+           *
+           * Returns true when a drained row was found and returned to the queue.
+           */
+          requeueDrainedPendingEventByFingerprint(meshId, fingerprint) {
+            if (!fingerprint) return false;
+            const changes = this.db.prepare(
+              `UPDATE mesh_pending_events SET drained = 0, drained_at = NULL
+             WHERE mesh_id = ? AND fingerprint = ? AND drained = 1`
+            ).run(meshId, fingerprint).changes;
+            if (changes > 0) this.maybeCheckpointWal();
+            return changes > 0;
+          }
           /**
            * Hard-delete pending-event rows by id (including the dedup fingerprint history).
            * Used to expire an unresolved-delegate outbox entry that has exhausted its retry
@@ -60859,23 +60928,51 @@ ${cleanBody}`;
     async function pollAssignedTaskTerminalEvidence(components, mesh, row, opts) {
       const sessionId = readNonEmptyString(row.assignedSessionId);
       const nodeId = readNonEmptyString(row.assignedNodeId);
-      if (!sessionId || !nodeId) return null;
+      const traceCtx = {
+        taskId: row.id,
+        ...sessionId ? { sessionId } : {},
+        ...nodeId ? { nodeId } : {},
+        meshId: mesh.id,
+        event: "agent:generating_completed"
+      };
+      const declined = (reason, detail) => {
+        traceMeshEventDrop(`poll_terminal_evidence_${reason}`, traceCtx, detail);
+        return null;
+      };
+      if (!sessionId || !nodeId) {
+        return declined("no_assigned_worker", `sessionId=${sessionId ?? "none"} nodeId=${nodeId ?? "none"}`);
+      }
       const providerType = readNonEmptyString(row.assignedProviderType);
       const payload = await runSessionEvidenceCollection(sessionId, () => fetchAssignedTaskChatTail(components, mesh, row));
-      if (!payload) return null;
-      if (readChatPayloadStatus(payload) !== "idle") return null;
+      if (!payload) return declined("chat_tail_unreadable", "worker transcript read returned no payload (offline/unreachable?)");
+      const payloadStatus = readChatPayloadStatus(payload);
+      if (payloadStatus !== "idle") return declined("session_not_idle", `status=${payloadStatus ?? "unknown"} \u2014 mid-turn, not a turn-end`);
       const messages = Array.isArray(payload.messages) ? payload.messages : [];
       const evidence = extractFinalAssistantSummaryEvidence(messages);
-      if (!evidence.finalSummary) return null;
-      if (hasTrailingToolActivityAfterFinalAssistant(messages)) return null;
+      if (!evidence.finalSummary) return declined("no_final_assistant_summary", `idle with ${messages.length} message(s) but no assistant result`);
+      if (hasTrailingToolActivityAfterFinalAssistant(messages)) {
+        return declined("trailing_tool_activity", "tool/terminal bubble trails the final assistant \u2014 worker is mid-turn");
+      }
       const dispatchedAtMs = Date.parse(readNonEmptyString(row.dispatchTimestamp));
       const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? "");
       if (!(Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs >= dispatchedAtMs)) {
-        return null;
+        const unusable = !Number.isFinite(dispatchedAtMs) || !Number.isFinite(transcriptAtMs);
+        return declined(
+          unusable ? "timestamp_unusable" : "summary_predates_dispatch",
+          `dispatchTimestamp=${row.dispatchTimestamp ?? "none"} transcriptMessageAt=${evidence.transcriptMessageAt ?? "none"}`
+        );
       }
       if (typeof opts?.minFinalAssistantAgeMs === "number" && opts.minFinalAssistantAgeMs > 0 && Date.now() - transcriptAtMs < opts.minFinalAssistantAgeMs) {
-        return null;
+        return declined(
+          "final_assistant_not_settled",
+          `age=${Date.now() - transcriptAtMs}ms < minFinalAssistantAgeMs=${opts.minFinalAssistantAgeMs} \u2014 treated as in-flight narration`
+        );
       }
+      traceMeshEventStage(
+        "poll_terminal_evidence_completed",
+        traceCtx,
+        `idle with final assistant after dispatch \u2014 task is completed, re-drive prevented`
+      );
       return {
         outcome: "completed",
         finalSummary: evidence.finalSummary,
@@ -61002,7 +61099,7 @@ ${cleanBody}`;
         ...force ? { force: true } : {}
       });
     }
-    function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldForCoordinatorCount) {
+    function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldForCoordinatorCount, strictRoutedFingerprints) {
       let pending;
       try {
         pending = getPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : void 0);
@@ -61010,6 +61107,7 @@ ${cleanBody}`;
         return;
       }
       for (const event of pending) {
+        if (strictRoutedFingerprints?.has(buildPendingEventFingerprint(event))) continue;
         if (!shouldForceInjectMeshEvent(event.event)) continue;
         const fingerprint = buildPendingEventFingerprint(event);
         const key2 = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ""}::${event.queuedAt}`}`;
@@ -62089,6 +62187,7 @@ ${cleanBody}`;
               meshCoordinators.map((c) => readNonEmptyString(c.sessionId)).filter(Boolean)
             );
             let orphanEscaped = 0;
+            const strictRoutedFingerprints = /* @__PURE__ */ new Set();
             const hasPendingForOrphanPeek = !store || (() => {
               try {
                 return store.pendingEventCount(meshId) > 0;
@@ -62123,10 +62222,11 @@ ${cleanBody}`;
                 for (const pending of drained) {
                   if (isOrphan(pending)) {
                     holdOrExpireStrictUnmatchedEvent(pending, readNonEmptyString(pending.targetCoordinatorSessionId), meshId);
+                    strictRoutedFingerprints.add(buildPendingEventFingerprint(pending));
                     orphanEscaped++;
                   } else {
                     try {
-                      queuePendingMeshCoordinatorEvent(pending);
+                      requeueDrainedPendingMeshCoordinatorEvent(pending);
                     } catch {
                     }
                   }
@@ -62149,7 +62249,8 @@ ${cleanBody}`;
                 meshId,
                 drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId ? [localDaemonId] : [],
                 "modal_parked",
-                modalParkedCoordinators.length
+                modalParkedCoordinators.length,
+                strictRoutedFingerprints
               );
             }
           } else if (generatingCoordinators.length > 0) {
@@ -62208,15 +62309,15 @@ ${cleanBody}`;
       const queuedAt = typeof pending.queuedAt === "number" ? pending.queuedAt : Date.now();
       if (Date.now() - queuedAt <= STRICT_SESSION_MATCH_TTL_MS) {
         try {
-          queuePendingMeshCoordinatorEvent(pending);
-          LOG2.info("MeshReconcile", `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} \u2014 re-queued (${pending.event})`);
+          const requeued = requeueDrainedPendingMeshCoordinatorEvent(pending);
+          LOG2.info("MeshReconcile", `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} \u2014 re-queued (${pending.event})${requeued ? "" : " [WARN: not durably re-queued]"}`);
           traceMeshEventDrop("strict_route_hold", {
             taskId: pending.metadataEvent?.taskId,
             sessionId: pending.metadataEvent?.targetSessionId ?? wantSession,
             nodeId: pending.nodeId,
             meshId,
             event: pending.event
-          }, `coordinatorSession=${wantSession} not live`);
+          }, `coordinatorSession=${wantSession} not live durable=${requeued}`);
         } catch (e) {
           LOG2.warn("MeshReconcile", `Strict route re-queue failed for ${pending.event} on mesh ${meshId}: ${e?.message || e}`);
         }