@adhdev/daemon-core 0.9.82-rc.519 → 0.9.82-rc.520

package/dist/mesh/mesh-node-identity.d.ts

@@ -81,6 +81,32 @@ export declare function normalizeInlineMeshNodeIdentity(inlineMesh: any): any;
 export declare function sanitizeInlineMesh(inlineMesh: any): any;
 export declare function reconcileInlineMeshCache(cached: any, incoming: any): any;
 export declare function deriveMeshNodeHealthFromGit(git: Record<string, unknown> | null | undefined): 'online' | 'dirty' | 'degraded';
+/**
+ * Resolve a node's EFFECTIVE health from whatever telemetry the node object carries,
+ * in the same precedence the coordinator surfaces use (applyCachedInlineMeshNodeStatus):
+ *   1. an explicit `node.health` scalar (set by a fresh mesh_status probe / status report),
+ *   2. else the cached inline status health (`node.cachedStatus.health`),
+ *   3. else derived from the node's git telemetry (`node.git` / cachedStatus.git) via
+ *      deriveMeshNodeHealthFromGit,
+ *   4. else 'unknown' (no telemetry — cannot prove unhealthy).
+ *
+ * This is the SINGLE source of truth for "what is this node's health right now" shared by
+ * the auto-launch gate (isMeshNodeHealthLaunchable → isLaunchableNode) and the MAGI fan-out
+ * planner, so the two never disagree about whether a degraded node is a viable target.
+ * Returns a lowercased string (empty string is normalized to 'unknown').
+ */
+export declare function resolveEffectiveMeshNodeHealth(node: any): string;
+/**
+ * Whether a node's health permits launching / assigning a fresh worker session onto it.
+ * Mirrors the auto-launch gate in mesh-queue-assignment.isLaunchableNode: 'online' and
+ * 'unknown' (and an absent/empty health, treated as unknown) pass — we never block on
+ * missing telemetry; every other resolved health ('degraded', 'offline', 'dirty',
+ * 'wrong_branch') is NOT launchable. A task assigned to a non-launchable node parks in
+ * `pending` forever (isLaunchableNode skips it → node_not_launch_ready) with no
+ * re-assignment, so the MAGI planner must exclude such nodes UP FRONT rather than emit a
+ * replica that can never run.
+ */
+export declare function isMeshNodeHealthLaunchable(node: any): boolean;
 export declare function applyInlineMeshBranchConvergence(mesh: any, node: any, status: Record<string, unknown>): void;
 export declare function summarizeInlineMeshBranchConvergence(nodes: Array<Record<string, unknown>>): Record<string, unknown>;
 export declare function readCachedInlineMeshActiveSessions(node: any): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.519",
+  "version": "0.9.82-rc.520",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.519",
-    "@adhdev/session-host-core": "0.9.82-rc.519",
+    "@adhdev/mesh-shared": "0.9.82-rc.520",
+    "@adhdev/session-host-core": "0.9.82-rc.520",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/index.ts

@@ -277,6 +277,9 @@ export type { AnyLedgerSlice, MeshLedgerReconciliationEvidence, MeshLedgerReplic
 // ── Mesh Work Queue (GUPP) ──
 export { enqueueTask, recordDirectDispatchTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest, isTaskReadonly, buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, normalizeMeshCapabilityTags, resolveConvergeRequiredTags, insertDirectDispatch, getActiveDirectDispatches, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, markStaleDirectDispatches, deleteDirectDispatchesByTaskId, recordMeshToolCall, assertNoDependencyCycle, hasPendingDependents, describeTaskDependencyState, taskDependenciesSatisfied, normalizeMeshTaskPriority, meshTaskPriorityRank, resolveNotBefore, meshTaskNotBeforeReady, MESH_TASK_PRIORITIES, NOT_BEFORE_RELATIVE_THRESHOLD_MS } from './mesh/mesh-work-queue.js';
 export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshTaskPriority, MeshWorkQueueStats, MeshQueueMutationOptions, MeshTaskModeValidationResult, DirectDispatchRecord, MeshToolCallRateResult } from './mesh/mesh-work-queue.js';
+// Shared node-health resolver + launch gate (single source of truth for the auto-launch
+// gate AND the MAGI fan-out planner — they must agree on what "launchable health" means).
+export { deriveMeshNodeHealthFromGit, resolveEffectiveMeshNodeHealth, isMeshNodeHealthLaunchable } from './mesh/mesh-node-identity.js';
 export { buildCompactStaleDirectWorkSummary, buildMeshActiveWork, buildMeshActiveWorkSummary, collectPendingApprovals, classifyStaleDirectForPrune, pruneStaleDirectDispatches, PRUNABLE_ORPHAN_STALE_REASONS } from './mesh/mesh-active-work.js';
 export type { StaleDirectPruneClassification, StaleDirectPruneResult, PruneStaleDirectDispatchesOptions } from './mesh/mesh-active-work.js';
 export type { MeshActiveWorkRecord, MeshActiveWorkStatus, MeshActiveWorkSummary, MeshActiveWorkSource, MeshStaleDirectWorkSummary, MeshPendingApproval } from './mesh/mesh-active-work.js';

package/src/mesh/mesh-node-identity.ts

@@ -865,6 +865,48 @@ export function deriveMeshNodeHealthFromGit(git: Record<string, unknown> | null
     return 'online';
 }
 
+/**
+ * Resolve a node's EFFECTIVE health from whatever telemetry the node object carries,
+ * in the same precedence the coordinator surfaces use (applyCachedInlineMeshNodeStatus):
+ *   1. an explicit `node.health` scalar (set by a fresh mesh_status probe / status report),
+ *   2. else the cached inline status health (`node.cachedStatus.health`),
+ *   3. else derived from the node's git telemetry (`node.git` / cachedStatus.git) via
+ *      deriveMeshNodeHealthFromGit,
+ *   4. else 'unknown' (no telemetry — cannot prove unhealthy).
+ *
+ * This is the SINGLE source of truth for "what is this node's health right now" shared by
+ * the auto-launch gate (isMeshNodeHealthLaunchable → isLaunchableNode) and the MAGI fan-out
+ * planner, so the two never disagree about whether a degraded node is a viable target.
+ * Returns a lowercased string (empty string is normalized to 'unknown').
+ */
+export function resolveEffectiveMeshNodeHealth(node: any): string {
+    const explicit = (readStringValue(node?.health) ?? '').toLowerCase();
+    if (explicit) return explicit;
+    const cachedStatus = readObjectRecord(node?.cachedStatus);
+    const cachedHealth = (readStringValue(cachedStatus.health) ?? '').toLowerCase();
+    if (cachedHealth) return cachedHealth;
+    const git = readObjectRecord(node?.git);
+    if (Object.keys(git).length > 0) return deriveMeshNodeHealthFromGit(git).toLowerCase();
+    const cachedGit = readObjectRecord(cachedStatus.git);
+    if (Object.keys(cachedGit).length > 0) return deriveMeshNodeHealthFromGit(cachedGit).toLowerCase();
+    return 'unknown';
+}
+
+/**
+ * Whether a node's health permits launching / assigning a fresh worker session onto it.
+ * Mirrors the auto-launch gate in mesh-queue-assignment.isLaunchableNode: 'online' and
+ * 'unknown' (and an absent/empty health, treated as unknown) pass — we never block on
+ * missing telemetry; every other resolved health ('degraded', 'offline', 'dirty',
+ * 'wrong_branch') is NOT launchable. A task assigned to a non-launchable node parks in
+ * `pending` forever (isLaunchableNode skips it → node_not_launch_ready) with no
+ * re-assignment, so the MAGI planner must exclude such nodes UP FRONT rather than emit a
+ * replica that can never run.
+ */
+export function isMeshNodeHealthLaunchable(node: any): boolean {
+    const health = resolveEffectiveMeshNodeHealth(node);
+    return health === 'online' || health === 'unknown';
+}
+
 function readMeshNodeLabel(status: Record<string, unknown>, node: any): string {
     return readStringValue(status.nodeId, normalizeMeshNodeId(node)) ?? 'unknown';
 }

package/src/mesh/mesh-queue-assignment.ts

@@ -19,7 +19,7 @@ import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalD
 import { resolveNodeCapabilitySlots } from './mesh-node-slots.js';
 import { findTerminalLedgerEvidenceForTask, hasUnterminalDirectDispatchLedgerEntry } from './mesh-events-stale.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
-import { readMeshNodeDaemonId } from './mesh-node-identity.js';
+import { readMeshNodeDaemonId, isMeshNodeHealthLaunchable } from './mesh-node-identity.js';
 import { queuePendingMeshCoordinatorEvent, retractPendingDispatchBlockedEvent } from './mesh-events-pending.js';
 import { isWorktreeBootstrapStaleRunning, shouldDeferDispatchForBootstrap } from './worktree-bootstrap-config.js';
 import { isWithinCloneBootstrapGrace } from './mesh-clone-grace.js';
@@ -1047,9 +1047,10 @@ function nodeHasActiveMeshWork(components: DaemonComponents, meshId: string, nod
 
 function isLaunchableNode(node: any): boolean {
     if (!node || node.status === 'disabled' || node.status === 'removed') return false;
-    const health = readNonEmptyString(node.health).toLowerCase();
-    if (!health) return true;
-    return health === 'online' || health === 'unknown';
+    // Delegate the health gate to the shared resolver so the auto-launch gate and the
+    // MAGI fan-out planner agree on exactly what "launchable health" means (online /
+    // unknown / absent pass; degraded / offline / dirty / wrong_branch are blocked).
+    return isMeshNodeHealthLaunchable(node);
 }
 
 /** Whether a mesh node's daemon/machine identity resolves to THIS coordinator daemon