@adhdev/daemon-core 0.9.82-rc.381 → 0.9.82-rc.382

package/dist/mesh/mesh-event-forwarding.d.ts

@@ -1,4 +1,5 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+export declare function recoverMeshIdByCoordinatorAndNode(coordinatorDaemonId: string, nodeId: string): string;
 export declare function resolveForwardEventMeshId(components: DaemonComponents, payload: Record<string, unknown>): string;
 export declare function __resetMeshWorkspaceCacheForTests(): void;
 export declare function buildRelayMetadataEvent(payload: Record<string, unknown>): Record<string, unknown>;

package/dist/providers/cli-provider-instance.d.ts

@@ -150,6 +150,24 @@ export declare class CliProviderInstance implements ProviderInstance {
      * terminal state. Leaving meshNodeFor pinned would route this session's
      * subsequent unrelated turns (e.g. ad-hoc dashboard chats) to the
      * coordinator as if they were task completions.
+     *
+     * MESHID-DROP-ON-DETACH (Fix C): a coordinator-LAUNCHED worker session
+     * (launchedByCoordinator) holds its mesh membership (meshNodeFor / meshNodeId /
+     * meshCoordinatorDaemonId) at the SESSION level — set once at launch
+     * (mesh_launch_session / queue auto-launch), independent of any single task.
+     * The original detach wiped meshNodeFor + meshNodeId together with the
+     * task-level meshActiveTaskId, so the FIRST task completion stripped the
+     * membership and EVERY subsequent completion forwarded with meshId absent —
+     * resolveWorkerDelegateRouting fell to mesh_unresolved and the coordinator
+     * rejected the forward "meshId required". For a launched member we therefore
+     * clear ONLY the task-level marker (meshActiveTaskId) and preserve the
+     * session-level membership so its next task's completion still resolves.
+     * A task-less ad-hoc turn on a preserved-membership session is NOT misrouted:
+     * its completion carries no taskId and the session holds no active assignment,
+     * so the forwarder's WARMUPGAP guard skips the dispatch-row flip (it only
+     * injects a benign task-less notification). A NON-launched session (a plain CLI
+     * session adopted by mesh_send_task --direct, launchedByCoordinator falsy)
+     * keeps the original full clear so an ad-hoc session is never left pinned.
      */
     detachMeshAssignment(): void;
     /**

package/package.json

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

package/src/commands/high-family/mesh-status.ts

@@ -107,6 +107,19 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                     const queue = getQueue(meshId);
                     const queueSummary = getMeshQueueStats(meshId);
 
+                    // Scheduling-runtime projection — the load-balancer's live view (tie-break
+                    // strategy, global parallel caps + consumption, per-node load/priority/provider
+                    // caps). Built from the SAME helper + args the MCP `mesh_status` tool uses
+                    // (mesh-tools-status.ts: buildMeshSchedulingRuntime(mesh, getQueue(mesh.id)))
+                    // so the dashboard surface and the coordinator MCP surface render an identical
+                    // runtime. Without this the dashboard Status/Runtime tab showed the
+                    // "not reported by this daemon (older build)" fallback (RepoMeshStatus.scheduling
+                    // was never populated by this daemon-command producer). Computed once so each
+                    // node entry can attach its slice and statusResult can carry the mesh rollup.
+                    const { buildMeshSchedulingRuntime } = await import('../../mesh/mesh-scheduling-runtime.js');
+                    const schedulingRuntime = buildMeshSchedulingRuntime(mesh, queue);
+                    const schedulingByNode = new Map(schedulingRuntime.nodes.map(n => [n.nodeId, n]));
+
                     const { readLedgerEntries, getLedgerSummary } = await import('../../mesh/mesh-ledger.js');
                     const ledgerEntries = readLedgerEntries(meshId, { tail: 20 });
                     const asyncRefineLedgerEntries = readLedgerEntries(meshId, { tail: 100 });
@@ -260,6 +273,16 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                             activeSessionDetails: [],
                             launchReady: false,
                         };
+                        // Per-node scheduling slice (load / priority / provider caps / claim-block
+                        // reasons) read by the dashboard's MeshNodeSchedulingBadges. Full shape —
+                        // unlike the MCP compact path this is a dashboard surface, so it keeps the
+                        // whole RepoMeshNodeSchedulingStatus. Redundant nodeId dropped (the entry
+                        // already carries it).
+                        const nodeScheduling = schedulingByNode.get(nodeId);
+                        if (nodeScheduling) {
+                            const { nodeId: _omitNodeId, ...nodeSchedulingRest } = nodeScheduling;
+                            status.scheduling = nodeSchedulingRest;
+                        }
                         if (isSelfNode) {
                             status.connection = {
                                 perspective: 'selected_coordinator',
@@ -511,6 +534,19 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         branchConvergenceSummary: summarizeInlineMeshBranchConvergence(nodeStatuses),
                         ...(previewFreshness ? { previewFreshness, deployFreshness: previewFreshness } : {}),
                         nodes: nodeStatuses,
+                        // Mesh-level scheduling rollup (strategy + global cap consumption). Mirrors
+                        // the MCP `mesh_status` tool's `scheduling` block field-for-field so both
+                        // surfaces read the same runtime; per-node detail lives on each
+                        // nodes[].scheduling above.
+                        scheduling: {
+                            strategy: schedulingRuntime.strategy,
+                            maxParallelTasks: schedulingRuntime.maxParallelTasks,
+                            maxReadonlyParallelTasks: schedulingRuntime.maxReadonlyParallelTasks,
+                            activeWriteAssigned: schedulingRuntime.activeWriteAssigned,
+                            activeReadonlyAssigned: schedulingRuntime.activeReadonlyAssigned,
+                            globalWriteCapReached: schedulingRuntime.globalWriteCapReached,
+                            globalReadonlyCapReached: schedulingRuntime.globalReadonlyCapReached,
+                        },
                         queue: { tasks: queue, summary: queueSummary },
                         ledger: { entries: ledgerEntries, summary: ledgerSummary },
                         ...(missions.length > 0 ? { missions } : {}),

package/src/mesh/mesh-event-forwarding.ts

@@ -9,6 +9,7 @@ import { markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompl
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents } from './mesh-events-pending.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
+import { resolveMeshHostStatus } from './mesh-host-ownership.js';
 import { enqueueUnresolvedDelegateForward, peekUnresolvedDelegateForwards, ackUnresolvedDelegateForward } from './mesh-unresolved-forward-outbox.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { getLastDisplayMessage } from '../status/snapshot.js';
@@ -92,6 +93,38 @@ function recoverMeshIdByNodeId(nodeId: string): string {
     return '';
 }
 
+// MESHID-DROP coordinator-anchor recovery (Fix B): the last-resort meshId recovery for an
+// unresolved-delegate forward whose payload carries the worker's coordinator anchor
+// (meshCoordinatorDaemonId) but no resolvable meshId — neither workspace nor nodeId scan
+// matched (a freshly-cloned worktree node not yet registered under the forwarded id form, or
+// an empty payload nodeId). The receiving daemon IS the coordinator/host, so scope to the
+// meshes IT hosts whose host daemon matches the anchor (daemonIdsEquivalent — never a raw
+// compare, so daemon_mach_/mach_/standalone_ forms all match the same machine). Among those:
+//   • a nodeId → the mesh whose nodes contain it (meshNodeIdMatches 3-form) wins;
+//   • no nodeId → fall back to the anchor's SINGLE hosted mesh only. Ambiguity (the anchor
+//     hosts >1 mesh and no node disambiguates) returns '' rather than guess — a wrong meshId
+//     would inject the completion into an unrelated mesh's ledger, worse than the retry-cap drop.
+export function recoverMeshIdByCoordinatorAndNode(coordinatorDaemonId: string, nodeId: string): string {
+    if (!coordinatorDaemonId) return '';
+    const hosted = listMeshes().filter(mesh => {
+        const host = resolveMeshHostStatus(mesh);
+        return host.role === 'host'
+            && (!host.hostDaemonId || daemonIdsEquivalent(host.hostDaemonId, coordinatorDaemonId));
+    });
+    if (hosted.length === 0) return '';
+    if (nodeId) {
+        const byNode = hosted.find(mesh =>
+            Array.isArray(mesh.nodes) && mesh.nodes.some((n: any) => meshNodeIdMatches(n, nodeId)));
+        if (byNode) return readNonEmptyString(byNode.id);
+        // nodeId present but matched no hosted mesh — do NOT fall through to the single-mesh
+        // guess; the node belongs to a mesh we don't host (or under a different id), and
+        // guessing would misroute. Stay unresolved.
+        return '';
+    }
+    // No nodeId to disambiguate: only safe when the anchor hosts exactly one mesh.
+    return hosted.length === 1 ? readNonEmptyString(hosted[0].id) : '';
+}
+
 // RECONCILE-MESHID-DROP: WORKER-side meshId resolution for an unresolved-delegate
 // forward payload. forwardUnresolvedDelegateEvent omits meshId by design (the worker
 // "can't resolve it") and relies on the COORDINATOR recovering it from workspace/nodeId.
@@ -1234,7 +1267,14 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
     // The nodeId is a stable coordinator-side fact and resolves timing-independently.
     const meshId = readNonEmptyString(payload.meshId)
         || (workspace ? readNonEmptyString(getCachedMeshByWorkspace(workspace)?.id) : '')
-        || recoverMeshIdByNodeId(nodeId);
+        || recoverMeshIdByNodeId(nodeId)
+        // Fix B last resort: workspace + nodeId scan both missed, but the worker stamped
+        // its coordinator anchor onto the forward (forwardUnresolvedDelegateEvent). Recover
+        // via the hosted mesh that anchor owns (+ node disambiguation), guarding ambiguity.
+        || recoverMeshIdByCoordinatorAndNode(
+            readNonEmptyString(payload.meshCoordinatorDaemonId) || readNonEmptyString(payload.coordinatorDaemonId),
+            nodeId,
+        );
     if (!meshId) {
         // EVTTRACE: forwarded event rejected at receive — no meshId could be resolved
         // (no payload.meshId, no workspace→mesh, no nodeId→mesh). Observation only.
@@ -1364,6 +1404,11 @@ function forwardUnresolvedDelegateEvent(
         event: eventName,
         nodeId: readNonEmptyString(routing.nodeId) || readNonEmptyString(event.meshNodeId) || undefined,
         workspace: readNonEmptyString(routing.workspace) || readNonEmptyString(event.workspace) || undefined,
+        // Fix B: carry the resolved coordinator anchor so the coordinator's receive-side
+        // recovery (recoverMeshIdByCoordinatorAndNode) can match this forward to one of the
+        // meshes it hosts when workspace + nodeId both miss. routing.coordinatorDaemonId is
+        // the same anchor this forward is addressed to (coordinatorDaemonId below).
+        meshCoordinatorDaemonId: coordinatorDaemonId,
     };
     // RECONCILE-MESHID-DROP: stamp meshId when the WORKER can resolve it (member node /
     // live-session meshNodeFor). Historically omitted "because the worker can't resolve

package/src/providers/cli-provider-instance.ts

@@ -972,9 +972,36 @@ export class CliProviderInstance implements ProviderInstance {
      * terminal state. Leaving meshNodeFor pinned would route this session's
      * subsequent unrelated turns (e.g. ad-hoc dashboard chats) to the
      * coordinator as if they were task completions.
+     *
+     * MESHID-DROP-ON-DETACH (Fix C): a coordinator-LAUNCHED worker session
+     * (launchedByCoordinator) holds its mesh membership (meshNodeFor / meshNodeId /
+     * meshCoordinatorDaemonId) at the SESSION level — set once at launch
+     * (mesh_launch_session / queue auto-launch), independent of any single task.
+     * The original detach wiped meshNodeFor + meshNodeId together with the
+     * task-level meshActiveTaskId, so the FIRST task completion stripped the
+     * membership and EVERY subsequent completion forwarded with meshId absent —
+     * resolveWorkerDelegateRouting fell to mesh_unresolved and the coordinator
+     * rejected the forward "meshId required". For a launched member we therefore
+     * clear ONLY the task-level marker (meshActiveTaskId) and preserve the
+     * session-level membership so its next task's completion still resolves.
+     * A task-less ad-hoc turn on a preserved-membership session is NOT misrouted:
+     * its completion carries no taskId and the session holds no active assignment,
+     * so the forwarder's WARMUPGAP guard skips the dispatch-row flip (it only
+     * injects a benign task-less notification). A NON-launched session (a plain CLI
+     * session adopted by mesh_send_task --direct, launchedByCoordinator falsy)
+     * keeps the original full clear so an ad-hoc session is never left pinned.
      */
     detachMeshAssignment(): void {
         if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
+        // Session-level member: keep membership, drop only the task-level marker.
+        if (this.settings.launchedByCoordinator === true) {
+            if (!this.settings.meshActiveTaskId) return;
+            const { meshActiveTaskId, ...rest } = this.settings;
+            void meshActiveTaskId;
+            this.settings = rest;
+            this.adapter.updateRuntimeSettings?.(this.settings);
+            return;
+        }
         const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
         void meshNodeFor; void meshActiveTaskId;
         // WTCLAIM (A): clear the active binding but PRESERVE the last bound node id