@adhdev/daemon-core 0.9.82-rc.360 → 0.9.82-rc.361

package/src/mesh/contracts.ts

@@ -28,6 +28,8 @@
  * types and leaves runtime behaviour unchanged.
  */
 
+import { daemonIdsEquivalent, machineCoreFromDaemonId } from '@adhdev/mesh-shared';
+
 /** Provider type identifier (e.g. 'claude-cli', 'codex-cli', 'roo-code').
  *  Free-form string; no shared enum exists in daemon-core yet. */
 type ProviderType = string;
@@ -76,15 +78,22 @@ export interface CoordinatorIdentity {
 }
 
 export function coordinatorIdentityEquals(a: CoordinatorIdentity, b: CoordinatorIdentity): boolean {
-  return a.daemonId === b.daemonId
+  // daemonId compares by machine core: the same daemon answers to three
+  // interchangeable id forms (mach_X / daemon_mach_X / standalone_mach_X), so a
+  // raw `===` would treat one coordinator addressed under two forms as distinct.
+  return daemonIdsEquivalent(a.daemonId, b.daemonId)
       && a.coordinatorRunId === b.coordinatorRunId
       && (a.sessionId ?? '') === (b.sessionId ?? '');
 }
 
 export function coordinatorIdentityKey(identity: CoordinatorIdentity): string {
   // Stable string form for map keys and ledger payloads. Avoids the
-  // {a:b, c:d} JSON.stringify ordering trap by enforcing field order.
-  return `${identity.daemonId}|${identity.coordinatorRunId}|${identity.sessionId ?? ''}`;
+  // {a:b, c:d} JSON.stringify ordering trap by enforcing field order. The
+  // daemonId is normalized to its machine core so the key stays consistent with
+  // coordinatorIdentityEquals — two equal identities addressed under different
+  // daemon-id forms must produce the SAME key (else equal-but-distinct-key bug).
+  const daemonCore = machineCoreFromDaemonId(identity.daemonId) ?? identity.daemonId;
+  return `${daemonCore}|${identity.coordinatorRunId}|${identity.sessionId ?? ''}`;
 }
 
 // ─── Session handle ──────────────────────────────────────────────────────

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

@@ -2444,7 +2444,7 @@ function ackUnresolvedDelegateForwardByFingerprint(
     payload: Record<string, unknown>,
 ): void {
     const match = peekUnresolvedDelegateForwards().find(entry =>
-        entry.coordinatorDaemonId === coordinatorDaemonId
+        daemonIdsEquivalent(entry.coordinatorDaemonId, coordinatorDaemonId)
         && readNonEmptyString(entry.payload.event) === eventName
         && readNonEmptyString(entry.payload.targetSessionId || entry.payload.sessionId || entry.payload.instanceId)
             === readNonEmptyString(payload.targetSessionId || payload.sessionId || payload.instanceId)

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

@@ -10,26 +10,6 @@ export function readRecord(value: unknown): Record<string, unknown> | undefined
         : undefined;
 }
 
-// A single daemon is identified three ways across the system: the raw machineId
-// (`mach_X`, what loadConfig().machineId returns and what the core forwarder uses as
-// localDaemonId), the cloud daemon id (`daemon_mach_X`), and the standalone daemon id
-// (`standalone_mach_X`, the runtime instanceId the MCP coordinator reports as
-// ctx.localDaemonId). Worker envelope stamps (meshCoordinatorDaemonId) and coordinator
-// drains use the prefixed forms, while the forwarder compares against the raw id — so a
-// naive `===` treats the same daemon as remote and breaks both coordinator matching and
-// the R3 direct-delivered dedup. Canonicalize to the raw id before comparing.
-export function canonicalDaemonId(value: unknown): string {
-    const id = readNonEmptyString(value);
-    if (!id) return '';
-    return id.replace(/^(?:daemon|standalone)_/, '');
-}
-
-export function sameDaemonId(a: unknown, b: unknown): boolean {
-    const ca = canonicalDaemonId(a);
-    const cb = canonicalDaemonId(b);
-    return ca !== '' && ca === cb;
-}
-
 /**
  * The relay-safety metadata a worker session must carry so that its completion /
  * generating events route back to the coordinator proactively (without waiting for

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

@@ -910,7 +910,13 @@ export class CliProviderInstance implements ProviderInstance {
         this.settings = {
             ...this.settings,
             meshNodeFor: assignment.meshId,
-            ...(assignment.nodeId ? { meshNodeId: assignment.nodeId } : {}),
+            // WTCLAIM (A): track the bound node id under BOTH the active marker
+            // (meshNodeId, cleared on detach) and a sticky marker (meshLastNodeId,
+            // preserved across detach). The sticky marker lets a detached but still
+            // coordinator-owned session be re-picked ONLY for the SAME node it served
+            // — never auto-adopted for a sibling node (e.g. a cloned worktree) that
+            // shares this daemon. See isMeshOwnedDelegateSession's post-detach gate.
+            ...(assignment.nodeId ? { meshNodeId: assignment.nodeId, meshLastNodeId: assignment.nodeId } : {}),
             ...(assignment.taskId ? { meshActiveTaskId: assignment.taskId } : {}),
             ...(assignment.coordinatorDaemonId ? { meshCoordinatorDaemonId: assignment.coordinatorDaemonId } : {}),
             // Session-level routing anchor: the originating coordinator session, so this
@@ -929,8 +935,15 @@ export class CliProviderInstance implements ProviderInstance {
     detachMeshAssignment(): void {
         if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
         const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
-        void meshNodeFor; void meshNodeId; void meshActiveTaskId;
-        this.settings = rest;
+        void meshNodeFor; void meshActiveTaskId;
+        // WTCLAIM (A): clear the active binding but PRESERVE the last bound node id
+        // (meshLastNodeId) so a later sessionless dispatch can re-adopt this idle
+        // session ONLY for the node it last served. Carry the id being cleared, or
+        // keep an already-present sticky marker if meshNodeId was absent.
+        const lastNodeId = (typeof meshNodeId === 'string' && meshNodeId.trim())
+            ? meshNodeId.trim()
+            : (typeof rest.meshLastNodeId === 'string' && rest.meshLastNodeId.trim() ? rest.meshLastNodeId.trim() : undefined);
+        this.settings = lastNodeId ? { ...rest, meshLastNodeId: lastNodeId } : rest;
         this.adapter.updateRuntimeSettings?.(this.settings);
     }