@adhdev/daemon-core 0.9.82-rc.297 → 0.9.82-rc.298

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.297",
+  "version": "0.9.82-rc.298",
   "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.297",
+    "@adhdev/mesh-shared": "0.9.82-rc.298",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/mesh/mesh-events-coordinator.ts

@@ -15,7 +15,7 @@ import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
 import { enqueueUnresolvedDelegateForward, peekUnresolvedDelegateForwards, ackUnresolvedDelegateForward } from './mesh-unresolved-forward-outbox.js';
 import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
-import { normalizeMeshNodeId, meshNodeIdMatches } from '@adhdev/mesh-shared';
+import { normalizeMeshNodeId, meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
     hasDispatchAfterTerminal,
@@ -109,7 +109,10 @@ function hasRecentIntentionalCleanupStop(meshId: string, sessionId?: string, nod
         if (!Number.isNaN(timestamp) && timestamp < cutoff) break;
         if (!isIntentionalCleanupStopEntry(entry)) continue;
         if (sessionId && entry.sessionId === sessionId) return true;
-        if (!sessionId && nodeId && entry.nodeId === nodeId) return true;
+        // Normalized node-id match (P4): the cleanup-stop entry's node id may be stored as
+        // `nodeId` or `node_id` and the `nodeId` arg can be in either form — a raw `===`
+        // would miss a genuine intentional-cleanup entry and fail to suppress the stop event.
+        if (!sessionId && nodeId && meshNodeIdMatches(entry as unknown as MeshNodeIdentified, nodeId)) return true;
     }
     return false;
 }

package/src/mesh/mesh-events-stale.ts

@@ -4,6 +4,7 @@ import { updateDirectDispatchStatus, cleanupTerminalDirectDispatches } from './m
 import { markSessionDeliveriesTerminal } from './mesh-delivery-policy.js';
 import { queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { readNonEmptyString, readRecord, resolveEventSessionId, readWorkerResultMetadata } from './mesh-events-utils.js';
+import { meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 
 // ---------------------------------------------------------------------------
 // Stale direct-dispatch detection & transcript reconciliation
@@ -25,7 +26,13 @@ export function findRecentTerminalLedgerEvidence(args: {
         if (args.sessionId && entry.sessionId === args.sessionId) {
             return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
         }
-        if (!args.sessionId && args.nodeId && entry.nodeId === args.nodeId) {
+        // Normalized node-id match (P4): a ledger entry may store its node id as `nodeId`
+        // (runtime form) or `node_id` (DB column form leaked onto the object). A raw `===`
+        // against args.nodeId drops the entry when the entry's stored form differs from the
+        // form the caller passes, so a valid terminal completion goes unfound. meshNodeIdMatches
+        // normalizes the entry across all 3 forms before comparing. (The entry's typed shape
+        // omits the open index signature MeshNodeIdentified declares, hence the cast.)
+        if (!args.sessionId && args.nodeId && meshNodeIdMatches(entry as unknown as MeshNodeIdentified, args.nodeId)) {
             return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
         }
     }

package/src/mesh/mesh-routing.ts

@@ -4,6 +4,7 @@ import { hasUnterminalDirectDispatchLedgerEntry } from './mesh-events-stale.js';
 import { appendLedgerEntry, readLedgerEntries } from './mesh-ledger.js';
 import { LOG } from '../logging/logger.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
+import { meshNodeIdMatches } from '@adhdev/mesh-shared';
 
 // ---------------------------------------------------------------------------
 // R1: single-source coordinator routing resolution
@@ -141,13 +142,28 @@ export function resolveWorkerDelegateRouting(
     const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
     if (!meshId) return reject('mesh_unresolved');
 
-    const targetNode = mesh?.nodes?.find((n: any) => n.workspace === workspace);
-    const nodeId = readNonEmptyString(targetNode?.id) || runtimeNodeId;
-    const nodeLabel = targetNode
-        ? `Node '${targetNode.id}'`
-        : runtimeNodeId
-            ? `Node '${runtimeNodeId}'`
-            : `Agent at ${workspace}`;
+    // Node resolution authority: the runtime stamp (meshNodeId) is the worker's
+    // own identity, set when the coordinator dispatched/launched it. Trust it FIRST,
+    // matched against mesh.nodes with the 3-form normalizer (id / nodeId / node_id).
+    // Workspace lookup is only a fallback for workers that never carried a node stamp.
+    //
+    // This is the P1 fix: a worktree clone and its base node can share the same
+    // `workspace`, or a freshly-cloned node may not yet be in mesh.nodes — in either
+    // case `.find(n => n.workspace === workspace)` would match the BASE node (or
+    // undefined) and stamp the completion event with the wrong/absent nodeId, so the
+    // event fails post-hoc node matching and the coordinator never sees the completion.
+    // The stamped meshNodeId splits base vs worktree correctly even on shared workspace.
+    const stampedNode = runtimeNodeId
+        ? mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, runtimeNodeId))
+        : undefined;
+    const targetNode = stampedNode || mesh?.nodes?.find((n: any) => n.workspace === workspace);
+    const nodeId = runtimeNodeId || readNonEmptyString(targetNode?.id);
+    // Label off the resolved nodeId (which now prefers the stamp) so a node matched
+    // by its `nodeId`/`node_id` form — where `targetNode.id` may be absent — never
+    // renders as `Node 'undefined'`.
+    const nodeLabel = nodeId
+        ? `Node '${nodeId}'`
+        : `Agent at ${workspace}`;
 
     return {
         isDelegate: true,