@adhdev/daemon-standalone 0.9.82-rc.533 → 0.9.82-rc.535

package/dist/index.js

@@ -30208,10 +30208,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "4bcba3bd84cc9f4cd08a3d93965f10f43fcf5dad" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "4bcba3bd" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.533" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-15T07:46:12.141Z" : void 0);
+      const commit = readInjected(true ? "207830c90b06f2f738a85f74079a2460d53767c8" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "207830c9" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.535" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-15T10:23:33.822Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -35486,12 +35486,16 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         return [];
       }
     }
+    function consumeSessionDelivery(meshId, sessionId, status, taskId) {
+      try {
+        return MeshRuntimeStore.getInstance().consumeSessionDelivery(meshId, sessionId, status, taskId);
+      } catch {
+        return 0;
+      }
+    }
     function markSessionDeliveriesTerminal(meshId, sessionId, terminalStatus) {
       try {
-        const active = MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
-        for (const delivery of active) {
-          MeshRuntimeStore.getInstance().updateSessionDeliveryStatus(delivery.id, terminalStatus);
-        }
+        MeshRuntimeStore.getInstance().markOpenSessionDeliveriesTerminal(meshId, sessionId, terminalStatus);
       } catch {
       }
     }
@@ -37556,6 +37560,25 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
             });
             this.maybeCheckpointWal();
           }
+          // DELIVERED-NOT-CONSUMED-REDRIVE monotonic FSM: the forward-progress lifecycle of a
+          // delivery is a strictly increasing rank — a status may only advance, never regress.
+          // The redrive bug was a NON-monotonic FSM: the transport-confirm callback
+          // (mesh-queue-assignment :384) writes 'delivered' unconditionally by PK, so when the
+          // worker's agent:generating_started raced AHEAD of the confirm and already flipped the
+          // row 'delivering'→'acked', the late confirm CLOBBERED 'acked' back to 'delivered'.
+          // taskDeliveryConsumed() (which keys on 'acked'/'completed') then read false forever,
+          // and the short-grace re-drive re-opened an already-consumed task. Enforcing the rank
+          // ordering here makes the two event orders converge on the same monotone terminal state
+          // regardless of arrival order, so a late confirm can never demote a consumed delivery.
+          // 'failed'/'expired'/'cancelled' are absorbing OUTCOMES, not progress ranks — they are
+          // always allowed (a genuine dispatch failure must be recordable even from 'acked').
+          static DELIVERY_PROGRESS_RANK = {
+            queued: 0,
+            delivering: 1,
+            delivered: 2,
+            acked: 3,
+            completed: 4
+          };
           updateSessionDeliveryStatus(id, status, opts) {
             const now = (/* @__PURE__ */ new Date()).toISOString();
             if (opts?.incrementAttempt) {
@@ -37564,13 +37587,75 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
                 SET status = @status, last_error = @lastError, attempt_count = attempt_count + 1, updated_at = @updatedAt
                 WHERE id = @id
             `).run({ id, status, lastError: opts?.lastError ?? null, updatedAt: now });
-            } else {
+              return;
+            }
+            const targetRank = _MeshRuntimeStore.DELIVERY_PROGRESS_RANK[status];
+            if (targetRank === void 0) {
               this.db.prepare(`
                 UPDATE mesh_session_delivery
                 SET status = @status, last_error = @lastError, updated_at = @updatedAt
                 WHERE id = @id
             `).run({ id, status, lastError: opts?.lastError ?? null, updatedAt: now });
+              return;
+            }
+            this.db.prepare(`
+            UPDATE mesh_session_delivery
+            SET status = @status, last_error = @lastError, updated_at = @updatedAt
+            WHERE id = @id AND (@targetRank >= CASE status
+                WHEN 'queued' THEN 0 WHEN 'delivering' THEN 1 WHEN 'delivered' THEN 2
+                WHEN 'acked' THEN 3 WHEN 'completed' THEN 4 ELSE 99 END)
+        `).run({ id, status, lastError: opts?.lastError ?? null, updatedAt: now, targetRank });
+          }
+          /**
+           * DELIVERED-NOT-CONSUMED-REDRIVE consume path. Advance a task's delivery record(s) to a
+           * CONSUMED status ('acked' or 'completed'), matching on mesh + session (+ taskId when the
+           * event names one) and INCLUDING rows already in 'delivered'/'acked'/'delivering'.
+           *
+           * The ack/terminal callers previously routed through getActiveSessionDeliveries(), whose SQL
+           * EXCLUDES 'delivered' — so in the normal event order (transport confirm flips 'delivered'
+           * BEFORE the worker's generating_started fires) the ack matched zero rows and the delivery
+           * was stranded 'delivered', never 'acked'. This finds the row by (mesh, session[, task])
+           * directly and relies on updateSessionDeliveryStatus's monotonic guard to only advance it.
+           * Returns the number of rows advanced.
+           */
+          consumeSessionDelivery(meshId, sessionId, status, taskId) {
+            const rows = this.db.prepare(
+              taskId ? `SELECT id, session_id FROM mesh_session_delivery
+                     WHERE mesh_id = ? AND task_id = ?
+                       AND status IN ('queued','delivering','delivered','acked')` : `SELECT id, session_id FROM mesh_session_delivery
+                     WHERE mesh_id = ? AND session_id = ?
+                       AND status IN ('queued','delivering','delivered','acked')`
+            ).all(meshId, taskId ?? sessionId);
+            let advanced = 0;
+            for (const r of rows) {
+              if (!sessionIdsEquivalent(r.session_id ?? void 0, sessionId)) continue;
+              this.updateSessionDeliveryStatus(r.id, status);
+              advanced++;
+            }
+            return advanced;
+          }
+          /**
+           * DELIVERED-NOT-CONSUMED-REDRIVE terminal path. Mark every OPEN delivery for a session
+           * (queued/delivering/delivered/acked) terminal on task completion/failure. The prior
+           * markSessionDeliveriesTerminal() routed through getActiveSessionDeliveries(), whose SQL
+           * EXCLUDES 'delivered'/'completed' — so a 'delivered' row (the common case, since the
+           * transport confirm flips it before the completion event) was never marked terminal and
+           * stayed 'delivered', keeping taskDeliveryConsumed() false and feeding the false re-drive.
+           * We match rows in OPEN states directly here. 'completed' advances monotonically (it is the
+           * top progress rank); 'failed' is an absorbing outcome written unconditionally.
+           */
+          markOpenSessionDeliveriesTerminal(meshId, sessionId, terminalStatus) {
+            const rows = this.db.prepare(
+              `SELECT id, session_id FROM mesh_session_delivery
+               WHERE mesh_id = ? AND status IN ('queued','delivering','delivered','acked')`
+            ).all(meshId);
+            let marked = 0;
+            for (const r of rows) {
+              if (!sessionIdsEquivalent(r.session_id ?? void 0, sessionId)) continue;
+              this.updateSessionDeliveryStatus(r.id, terminalStatus);
+              marked++;
             }
+            return marked;
           }
           getActiveSessionDeliveries(meshId, sessionId) {
             const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -50570,17 +50655,7 @@ ${cleanBody}`;
               updateDirectDispatchStatus(args.meshId, sessionId, "acked", soleTaskId);
             }
           }
-          const activeDeliveries = (() => {
-            try {
-              return MeshRuntimeStore.getInstance().getActiveSessionDeliveries(args.meshId, sessionId);
-            } catch {
-              return [];
-            }
-          })();
-          const deliveriesToAck = startedTaskId ? activeDeliveries.filter((d) => d.taskId === startedTaskId) : activeDeliveries;
-          for (const d of deliveriesToAck) {
-            updateSessionDeliveryStatus(d.id, "acked");
-          }
+          consumeSessionDelivery(args.meshId, sessionId, "acked", startedTaskId);
         }
       } else if (args.event === "agent:stopped") {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
@@ -52015,6 +52090,9 @@ ${cleanBody}`;
       for (const key2 of [...deliveredNoTurnUnknownStreak.keys()]) {
         if (key2.startsWith(meshKeyPrefix) && !assignedKeys.has(key2)) deliveredNoTurnUnknownStreak.delete(key2);
       }
+      for (const key2 of [...deliveredUnconsumedUnknownStreak.keys()]) {
+        if (key2.startsWith(meshKeyPrefix) && !assignedKeys.has(key2)) deliveredUnconsumedUnknownStreak.delete(key2);
+      }
       for (const row of assigned) {
         const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? "");
         if (!Number.isFinite(dispatchedAtMs)) continue;
@@ -52026,13 +52104,33 @@ ${cleanBody}`;
             updateTaskStatus(meshId, row.id, status);
             continue;
           }
+          const shortStreakKey = `${meshId}::${row.id}`;
           const verdict = row.assignedSessionId ? resolveSessionBusyVerdict(components, row.assignedSessionId) : "IDLE_CONFIRMED";
-          if (verdict !== "GENERATING") {
+          if (verdict === "GENERATING") {
+            deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
+          } else {
+            if (verdict === "IDLE_CONFIRMED") {
+              deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
+            } else {
+              const streak = (deliveredUnconsumedUnknownStreak.get(shortStreakKey) ?? 0) + 1;
+              deliveredUnconsumedUnknownStreak.set(shortStreakKey, streak);
+              if (streak < RECLAIM_UNKNOWN_GRACE_TICKS) {
+                traceMeshEventDrop("short_redrive_deferred_unknown_verdict", {
+                  taskId: row.id,
+                  sessionId: row.assignedSessionId,
+                  nodeId: row.assignedNodeId,
+                  meshId,
+                  event: "agent:generating_started"
+                }, `unknown ${streak}/${RECLAIM_UNKNOWN_GRACE_TICKS}`);
+                continue;
+              }
+            }
             const redriven = reclaimStrandedAssignedTask(meshId, row.id, {
               reason: "delivered_not_consumed_redrive",
               ageMs
             });
             if (redriven) {
+              deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
               LOG2.warn("MeshReconcile", `Re-drove delivered-but-unconsumed task ${row.id} on mesh ${meshId} (node=${row.assignedNodeId ?? "?"} session=${row.assignedSessionId ?? "?"}, delivered but no generating_started in ${Math.round(ageMs / 1e3)}s, verdict ${verdict} \u2192 ${redriven.status})`);
               traceMeshEventDrop("assigned_delivered_not_consumed_redrive", {
                 taskId: row.id,
@@ -52594,6 +52692,7 @@ ${cleanBody}`;
     var ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS;
     var RECLAIM_UNKNOWN_GRACE_TICKS;
     var deliveredNoTurnUnknownStreak;
+    var deliveredUnconsumedUnknownStreak;
     var ZOMBIE_ASSIGNED_MIN_AGE_MS;
     var STRICT_SESSION_MATCH_TTL_MS;
     var unresolvedForwardRejectionCounts;
@@ -52634,6 +52733,7 @@ ${cleanBody}`;
         ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS = 25e3;
         RECLAIM_UNKNOWN_GRACE_TICKS = 3;
         deliveredNoTurnUnknownStreak = /* @__PURE__ */ new Map();
+        deliveredUnconsumedUnknownStreak = /* @__PURE__ */ new Map();
         ZOMBIE_ASSIGNED_MIN_AGE_MS = 30 * 60 * 1e3;
         STRICT_SESSION_MATCH_TTL_MS = 6e4;
         unresolvedForwardRejectionCounts = /* @__PURE__ */ new Map();
@@ -56020,7 +56120,7 @@ ${cont}` : cont;
             if (!this.isWaitingForResponse || this.hasActionableApproval()) return false;
             const snap = this.transport.getSnapshot();
             const detectFn = typeof this.transport.runDetectStatus === "function" ? () => this.transport.runDetectStatus(snap.recentOutputBuffer) : () => this.runDetectStatus(snap);
-            const latestStatus = detectFn() || this.currentStatus;
+            const latestStatus = detectFn();
             if (latestStatus === "generating") {
               this.evaluateSettled(snap);
               return true;
@@ -84550,10 +84650,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
             candidates.push(path45.join(providerDir, "specs", "default.json"));
             candidates.push(path45.join(providerDir, "spec.json"));
             const specPath = candidates.find((p) => fs42.existsSync(p));
+            let nh;
             if (specPath) {
               resolved._resolvedSpecPath = specPath;
               let specControls;
-              let nh;
               try {
                 const rawSpec = JSON.parse(fs42.readFileSync(specPath, "utf8"));
                 specControls = rawSpec.control_bar;
@@ -84579,42 +84679,48 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   }
                 }
               }
-              if (nh) {
-                let reader = null;
-                let format = "spec";
-                if (nh.source) {
-                  format = `spec-${nh.source.kind}`;
-                  reader = (input) => executeNativeHistory(nh, input);
-                } else if (nh.override_path) {
-                  const overrideFile = path45.resolve(providerDir, nh.override_path);
-                  if (fs42.existsSync(overrideFile)) {
-                    try {
-                      registerProviderScriptRootSafely(path45.dirname(path45.dirname(providerDir)));
-                      delete require.cache[require.resolve(overrideFile)];
-                      const mod = require(overrideFile);
-                      const fn = typeof mod === "function" ? mod : mod && typeof mod.default === "function" ? mod.default : null;
-                      if (fn) {
-                        format = "spec-override";
-                        reader = (input) => fn(input);
-                      }
-                    } catch {
+            }
+            if (!nh) {
+              const inlineNh = base?.nativeHistory || resolved?.nativeHistory;
+              if (inlineNh && (inlineNh.source || inlineNh.override_path || inlineNh.reader)) {
+                nh = inlineNh;
+              }
+            }
+            if (nh) {
+              let reader = null;
+              let format = "spec";
+              if (nh.source) {
+                format = `spec-${nh.source.kind}`;
+                reader = (input) => executeNativeHistory(nh, input);
+              } else if (nh.override_path) {
+                const overrideFile = path45.resolve(providerDir, nh.override_path);
+                if (fs42.existsSync(overrideFile)) {
+                  try {
+                    registerProviderScriptRootSafely(path45.dirname(path45.dirname(providerDir)));
+                    delete require.cache[require.resolve(overrideFile)];
+                    const mod = require(overrideFile);
+                    const fn = typeof mod === "function" ? mod : mod && typeof mod.default === "function" ? mod.default : null;
+                    if (fn) {
+                      format = "spec-override";
+                      reader = (input) => fn(input);
                     }
+                  } catch {
                   }
-                } else if (nh.reader) {
-                  const dispatch = createNativeHistoryDispatcher(nh.reader);
-                  format = nh.reader;
-                  reader = (input) => dispatch(input);
-                }
-                if (reader) {
-                  resolved.scripts = { ...resolved.scripts || {} };
-                  resolved.scripts.readNativeHistory = reader;
-                  resolved.nativeHistory = {
-                    format,
-                    watchPath: void 0,
-                    scripts: { readSession: "readNativeHistory" },
-                    mode: "native-source"
-                  };
                 }
+              } else if (nh.reader) {
+                const dispatch = createNativeHistoryDispatcher(nh.reader);
+                format = nh.reader;
+                reader = (input) => dispatch(input);
+              }
+              if (reader) {
+                resolved.scripts = { ...resolved.scripts || {} };
+                resolved.scripts.readNativeHistory = reader;
+                resolved.nativeHistory = {
+                  format,
+                  watchPath: void 0,
+                  scripts: { readSession: "readNativeHistory" },
+                  mode: "native-source"
+                };
               }
             }
           } catch {