@adhdev/daemon-core 0.9.82-rc.487 → 0.9.82-rc.488

package/dist/commands/router-refine.d.ts

@@ -13,6 +13,20 @@ export declare function buildRefineJobHandle(self: DaemonCommandRouter, args: {
     retryOfJobId?: string;
     coordinatorDaemonId?: string;
 }): MeshRefineJobHandle;
+/**
+ * Slim the terminal-stage refine result down to the fields a coordinator needs to
+ * decide next-step, dropping the heavy per-command / per-entry detail.
+ *
+ * The full `CommandRouterResult` (with `validationSummary.commandsRun[]` carrying
+ * per-command stdout/stderr, `rejectedCommands`, `suggestions`, `suggestedConfig`,
+ * the full `patchEquivalence`, and `submoduleReachability.entries[]`/`.unreachable[]`)
+ * routinely exceeds 70KB and overflows the coordinator token limit when it rides on a
+ * `mesh_wait_events` payload. The full detail is still persisted verbatim to the ledger
+ * (`appendRefineJobLedger`) and `terminalRefineJobs`, so slimming only the EVENT loses
+ * nothing — the coordinator can pull the full record on demand via
+ * `evidence.ledgerCommand` / `taskHistoryKind`.
+ */
+export declare function slimRefineEventResult(result: Record<string, unknown>): Record<string, unknown>;
 export declare function queueRefineJobEvent(self: DaemonCommandRouter, event: 'refine:accepted' | 'refine:completed' | 'refine:failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): void;
 export declare function appendRefineJobLedger(self: DaemonCommandRouter, kind: 'task_dispatched' | 'task_completed' | 'task_failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): Promise<void>;
 /**

package/dist/index.js

@@ -414,10 +414,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "ef3ded0f5df148982ed222411ea08c6ab0fdb39b" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "ef3ded0f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.487" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-10T01:53:17.254Z" : void 0);
+  const commit = readInjected(true ? "a659fcbbe9641240de42b95804a16b8852c5b4eb" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "a659fcbb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.488" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-10T03:46:52.780Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -6175,6 +6175,7 @@ function reclaimStrandedAssignedTask(meshId, taskId, opts) {
     delete entry.assignedSessionId;
     delete entry.assignedProviderType;
     delete entry.dispatchTimestamp;
+    entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
     entry.strandedReclaimCount = reclaims;
     entry.updatedAt = now;
     endTaskDispatchInFlight(meshId, taskId);
@@ -7199,6 +7200,7 @@ var init_mesh_runtime_store = __esm({
           entry.assignedSessionId = sessionId;
           if (providerType) entry.assignedProviderType = providerType;
           entry.dispatchTimestamp = now;
+          entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
           entry.updatedAt = now;
           this.db.prepare(`
                 UPDATE mesh_queue SET
@@ -15657,6 +15659,10 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
             meshId,
             nodeId,
             taskId: task.id,
+            // REDRIVE-DUP: carry the current dispatch nonce so the worker can echo it
+            // back on generating_started; a reclaim bumps this row's nonce, making an
+            // already-in-flight stale inject rejectable on arrival.
+            ...typeof task.dispatchNonce === "number" ? { dispatchNonce: task.dispatchNonce } : {},
             ...localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {},
             ...sourceCoordinatorSessionId ? { coordinatorSessionId: sourceCoordinatorSessionId } : {}
           }
@@ -15715,6 +15721,8 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         meshId,
         nodeId,
         taskId: task.id,
+        // REDRIVE-DUP: carry the current dispatch nonce (see remote branch above).
+        ...typeof task.dispatchNonce === "number" ? { dispatchNonce: task.dispatchNonce } : {},
         ...localCoordinatorDaemonId() ? { coordinatorDaemonId: localCoordinatorDaemonId() } : {},
         ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {}
       }
@@ -19698,6 +19706,42 @@ function sourceWorkerAutoApproves(components, sessionId) {
     return false;
   }
 }
+function stopStaleMeshWorker(components, args) {
+  const { meshId, sessionId, providerType } = args;
+  const stopArgs = {
+    targetSessionId: sessionId,
+    ...providerType ? { cliType: providerType } : {},
+    mode: "hard",
+    reason: "stale_mesh_dispatch_reclaimed"
+  };
+  try {
+    const isLocal = components.cliManager?.adapters?.has?.(sessionId) === true;
+    if (isLocal) {
+      if (!stopArgs.cliType) {
+        const localType = components.cliManager?.adapters?.get?.(sessionId)?.cliType;
+        if (localType) stopArgs.cliType = localType;
+      }
+      Promise.resolve(components.cliManager?.handleCliCommand?.("stop_cli", stopArgs)).catch((e) => LOG.warn("MeshQueue", `Local stop of stale worker ${sessionId} failed: ${e?.message || e}`));
+      return;
+    }
+    let daemonId = args.daemonId;
+    if (!daemonId && args.nodeId) {
+      try {
+        const mesh = getMeshWithCache(components, meshId);
+        const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.nodeId));
+        daemonId = node ? readMeshNodeDaemonId(node) || void 0 : void 0;
+      } catch {
+      }
+    }
+    if (daemonId && components.dispatchMeshCommand) {
+      Promise.resolve(components.dispatchMeshCommand(daemonId, "stop_cli", stopArgs)).catch((e) => LOG.warn("MeshQueue", `Remote stop of stale worker ${sessionId} on daemon ${daemonId} failed: ${e?.message || e}`));
+    } else {
+      LOG.warn("MeshQueue", `Cannot stop stale worker ${sessionId}: no local adapter and no resolvable remote daemon id (node ${args.nodeId ?? "?"}). Ack already rejected \u2014 task will re-strand-and-fail if the worker completes.`);
+    }
+  } catch (e) {
+    LOG.warn("MeshQueue", `stopStaleMeshWorker error for ${sessionId}: ${e?.message || e}`);
+  }
+}
 function injectMeshSystemMessage(components, args) {
   const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
   const eventNodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
@@ -19937,6 +19981,35 @@ function injectMeshSystemMessage(components, args) {
     }
     if (sessionId) {
       const startedTaskId = readNonEmptyString2(args.metadataEvent.taskId) || void 0;
+      const startedNonce = typeof args.metadataEvent.dispatchNonce === "number" ? args.metadataEvent.dispatchNonce : void 0;
+      if (startedTaskId && startedNonce !== void 0) {
+        const currentRow = (() => {
+          try {
+            return MeshRuntimeStore.getInstance().findQueueEntryById(args.meshId, startedTaskId);
+          } catch {
+            return null;
+          }
+        })();
+        const currentNonce = typeof currentRow?.dispatchNonce === "number" ? currentRow.dispatchNonce : void 0;
+        if (currentNonce !== void 0 && startedNonce < currentNonce) {
+          LOG.warn("MeshQueue", `Rejecting stale mesh dispatch: task ${startedTaskId} generating_started from session ${sessionId} (node ${nodeId ?? "?"}) carries dispatchNonce ${startedNonce} < current ${currentNonce} \u2014 the task was reclaimed and re-dispatched; stopping this worker to prevent duplicate execution.`);
+          traceMeshEventDrop("stale_dispatch_nonce_rejected", {
+            taskId: startedTaskId,
+            sessionId,
+            nodeId,
+            meshId: args.meshId,
+            event: "agent:generating_started"
+          }, `nonce ${startedNonce} < ${currentNonce}`);
+          stopStaleMeshWorker(components, {
+            meshId: args.meshId,
+            sessionId,
+            nodeId,
+            providerType: readNonEmptyString2(args.metadataEvent.providerType) || readNonEmptyString2(args.metadataEvent.cliType),
+            daemonId: readNonEmptyString2(args.metadataEvent.sourceDaemonId) || readNonEmptyString2(args.metadataEvent.daemonId)
+          });
+          return { success: true, forwarded: 0, suppressed: true, staleDispatchRejected: true };
+        }
+      }
       if (startedTaskId) {
         updateDirectDispatchStatus(args.meshId, sessionId, "acked", startedTaskId);
       } else if (sessionHasActiveAssignment(args.meshId, sessionId)) {
@@ -20473,6 +20546,7 @@ var init_mesh_event_forwarding = __esm({
     init_dist();
     init_mesh_events_stale();
     init_mesh_task_inflight();
+    init_mesh_node_identity();
     init_mesh_events_utils();
     init_mesh_event_classify();
     init_mesh_queue_assignment();
@@ -45977,6 +46051,10 @@ var CliProviderInstance = class _CliProviderInstance {
       // shares this daemon. See isMeshOwnedDelegateSession's post-detach gate.
       ...assignment.nodeId ? { meshNodeId: assignment.nodeId, meshLastNodeId: assignment.nodeId } : {},
       ...assignment.taskId ? { meshActiveTaskId: assignment.taskId } : {},
+      // REDRIVE-DUP: task-level dispatch nonce, echoed on generating_started so the
+      // coordinator can reject a stale (reclaimed) dispatch. Cleared with meshActiveTaskId
+      // on detach so a subsequent unrelated turn never re-echoes a prior task's nonce.
+      ...typeof assignment.dispatchNonce === "number" ? { meshActiveDispatchNonce: assignment.dispatchNonce } : {},
       ...assignment.coordinatorDaemonId ? { meshCoordinatorDaemonId: assignment.coordinatorDaemonId } : {},
       // Session-level routing anchor: the originating coordinator session, so this
       // worker's completion events route back to the exact session that dispatched it.
@@ -46012,15 +46090,17 @@ var CliProviderInstance = class _CliProviderInstance {
     if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
     if (this.settings.launchedByCoordinator === true) {
       if (!this.settings.meshActiveTaskId) return;
-      const { meshActiveTaskId: meshActiveTaskId2, ...rest2 } = this.settings;
+      const { meshActiveTaskId: meshActiveTaskId2, meshActiveDispatchNonce: meshActiveDispatchNonce2, ...rest2 } = this.settings;
       void meshActiveTaskId2;
+      void meshActiveDispatchNonce2;
       this.settings = rest2;
       this.adapter.updateRuntimeSettings?.(this.settings);
       return;
     }
-    const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
+    const { meshNodeFor, meshNodeId, meshActiveTaskId, meshActiveDispatchNonce, ...rest } = this.settings;
     void meshNodeFor;
     void meshActiveTaskId;
+    void meshActiveDispatchNonce;
     const lastNodeId = typeof meshNodeId === "string" && meshNodeId.trim() ? meshNodeId.trim() : typeof rest.meshLastNodeId === "string" && rest.meshLastNodeId.trim() ? rest.meshLastNodeId.trim() : void 0;
     this.settings = lastNodeId ? { ...rest, meshLastNodeId: lastNodeId } : rest;
     this.adapter.updateRuntimeSettings?.(this.settings);
@@ -47509,6 +47589,9 @@ var CliProviderInstance = class _CliProviderInstance {
         const resolved = this.completingTurnTaskId();
         if (resolved) enrichedEvent.taskId = resolved;
       }
+      if (enrichedEvent.dispatchNonce === void 0 && typeof this.settings.meshActiveDispatchNonce === "number") {
+        enrichedEvent.dispatchNonce = this.settings.meshActiveDispatchNonce;
+      }
     }
     if (this.context?.emitProviderEvent) {
       this.context.emitProviderEvent(enrichedEvent);
@@ -50395,6 +50478,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 meshId: meshContext.meshId,
                 ...typeof meshContext.nodeId === "string" && meshContext.nodeId ? { nodeId: meshContext.nodeId } : {},
                 ...typeof meshContext.taskId === "string" && meshContext.taskId ? { taskId: meshContext.taskId } : {},
+                // REDRIVE-DUP: carry the dispatch nonce onto the worker session so
+                // its generating_started event echoes it back for the coordinator's
+                // stale-nonce guard.
+                ...typeof meshContext.dispatchNonce === "number" ? { dispatchNonce: meshContext.dispatchNonce } : {},
                 ...typeof meshContext.coordinatorDaemonId === "string" && meshContext.coordinatorDaemonId ? { coordinatorDaemonId: meshContext.coordinatorDaemonId } : {}
               });
             } catch {
@@ -59329,7 +59416,50 @@ function buildRefineJobHandle(self, args) {
     }
   };
 }
+function slimRefineEventResult(result) {
+  const slim = {};
+  for (const key2 of [
+    "success",
+    "code",
+    "error",
+    "convergenceStatus",
+    "blockedReason",
+    "branch",
+    "into",
+    "terminalKind",
+    "nextStep",
+    "finalBranchConvergenceState"
+  ]) {
+    if (result[key2] !== void 0) slim[key2] = result[key2];
+  }
+  if (Array.isArray(result.unreachableSubmoduleCommits)) {
+    slim.unreachableSubmoduleCommits = result.unreachableSubmoduleCommits.map((e) => ({ path: e?.path, autoPublishAllowed: e?.autoPublishAllowed }));
+  }
+  if (result.validationSummary && typeof result.validationSummary === "object") {
+    const vs = result.validationSummary;
+    slim.validationSummary = {
+      status: vs.status,
+      failureCode: vs.failureCode,
+      configSource: vs.configSource,
+      configSourceType: vs.configSourceType,
+      commandsRunCount: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : void 0
+    };
+  }
+  if (result.patchEquivalence && typeof result.patchEquivalence === "object") {
+    const pe = result.patchEquivalence;
+    slim.patchEquivalence = { status: pe.status, equivalent: pe.equivalent };
+  }
+  if (result.submoduleReachability && typeof result.submoduleReachability === "object") {
+    const sr = result.submoduleReachability;
+    slim.submoduleReachability = {
+      checked: Array.isArray(sr.entries) ? sr.entries.length : void 0,
+      unreachable: Array.isArray(sr.unreachable) ? sr.unreachable.length : void 0
+    };
+  }
+  return slim;
+}
 function queueRefineJobEvent(self, event, handle, result) {
+  const slimResult = result ? slimRefineEventResult(result) : void 0;
   const metadataEvent = {
     source: "refine_mesh_node_async_job",
     jobId: handle.jobId,
@@ -59342,7 +59472,7 @@ function queueRefineJobEvent(self, event, handle, result) {
     startedAt: handle.startedAt,
     completedAt: handle.completedAt,
     retryOfJobId: handle.retryOfJobId,
-    ...result ? { result } : {}
+    ...slimResult ? { result: slimResult } : {}
   };
   const eventPayload = {
     event,
@@ -59369,7 +59499,7 @@ function queueRefineJobEvent(self, event, handle, result) {
         startedAt: handle.startedAt,
         completedAt: handle.completedAt,
         retryOfJobId: handle.retryOfJobId,
-        ...result ? { result } : {}
+        ...slimResult ? { result: slimResult } : {}
       }
     );
     if (forwarded?.success === true) return;