@adhdev/daemon-standalone 1.0.29-rc.3 → 1.0.29-rc.4

package/dist/index.js

@@ -33311,10 +33311,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "8ee046ce7156a829d1038a65cb48221ca9bedb64" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "8ee046ce" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.29-rc.3" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-01T13:27:48.513Z" : void 0);
+      const commit = readInjected(true ? "df91f2d3a3bded96267f00003d1ee8e27dda0512" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "df91f2d3" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.29-rc.4" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-02T00:25:39.936Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -36258,6 +36258,7 @@ ${error48.message || ""}`;
       resolveScopedMeshId: () => resolveScopedMeshId,
       setDifficultyBrains: () => setDifficultyBrains,
       setMagiKindPanel: () => setMagiKindPanel,
+      setMeshHostPin: () => setMeshHostPin,
       tokenIdForManualPairing: () => tokenIdForManualPairing,
       updateMesh: () => updateMesh,
       updateNode: () => updateNode
@@ -36424,7 +36425,11 @@ ${error48.message || ""}`;
         defaultBranch: opts.defaultBranch,
         policy: mergeMeshPolicy(void 0, opts.policy),
         coordinator: opts.coordinator || {},
-        meshHost: opts.meshHost || createDefaultMeshHostMetadata(),
+        meshHost: opts.meshHost || (() => {
+          const base = createDefaultMeshHostMetadata();
+          const creatingDaemonId = typeof opts.hostDaemonId === "string" ? opts.hostDaemonId.trim() : "";
+          return creatingDaemonId ? { ...base, hostDaemonId: creatingDaemonId } : base;
+        })(),
         nodes: [],
         createdAt: now,
         updatedAt: now
@@ -36610,6 +36615,86 @@ ${error48.message || ""}`;
       saveMeshConfig(config2);
       return { accepted: true, mesh, meshHost: mesh.meshHost, node, tokenId: validation.tokenId };
     }
+    function setMeshHostPin(meshId, opts) {
+      const config2 = loadMeshConfig();
+      const mesh = config2.meshes.find((m) => m.id === meshId);
+      if (!mesh) return void 0;
+      const hostDaemonId = typeof opts.hostDaemonId === "string" ? opts.hostDaemonId.trim() : "";
+      const hostNodeId = typeof opts.hostNodeId === "string" ? opts.hostNodeId.trim() : "";
+      const previous = mesh.meshHost || createDefaultMeshHostMetadata();
+      if (!hostDaemonId && !hostNodeId) {
+        return {
+          mesh,
+          meshHost: previous,
+          applied: false,
+          reason: "invalid_host_daemon_id",
+          ...previous.hostDaemonId ? { hostDaemonId: previous.hostDaemonId } : {},
+          ...previous.hostNodeId ? { hostNodeId: previous.hostNodeId } : {}
+        };
+      }
+      if (previous.role === "member") {
+        return {
+          mesh,
+          meshHost: previous,
+          applied: false,
+          reason: "not_host_role",
+          ...previous.hostDaemonId ? { hostDaemonId: previous.hostDaemonId } : {},
+          ...previous.hostNodeId ? { hostNodeId: previous.hostNodeId } : {}
+        };
+      }
+      const existingDaemonId = typeof previous.hostDaemonId === "string" ? previous.hostDaemonId.trim() : "";
+      if (existingDaemonId && !opts.force) {
+        const sameHost = hostDaemonId ? daemonIdsEquivalent(existingDaemonId, hostDaemonId) : true;
+        if (!sameHost) {
+          return {
+            mesh,
+            meshHost: previous,
+            applied: false,
+            reason: "host_already_pinned",
+            hostDaemonId: existingDaemonId,
+            ...previous.hostNodeId ? { hostNodeId: previous.hostNodeId } : {}
+          };
+        }
+        const existingNodeId = typeof previous.hostNodeId === "string" ? previous.hostNodeId.trim() : "";
+        if (!hostNodeId || hostNodeId === existingNodeId) {
+          return {
+            mesh,
+            meshHost: previous,
+            applied: false,
+            reason: "already_pinned_same",
+            hostDaemonId: existingDaemonId,
+            ...existingNodeId ? { hostNodeId: existingNodeId } : {}
+          };
+        }
+      }
+      const now = opts.now || (/* @__PURE__ */ new Date()).toISOString();
+      const effectiveDaemonId = hostDaemonId || existingDaemonId;
+      mesh.meshHost = {
+        ...previous,
+        role: "host",
+        ...effectiveDaemonId ? { hostDaemonId: effectiveDaemonId } : {},
+        ...hostNodeId ? { hostNodeId } : previous.hostNodeId ? { hostNodeId: previous.hostNodeId } : {},
+        ...opts.hostAddress?.trim() ? { hostAddress: opts.hostAddress.trim() } : {}
+      };
+      const hostNode = hostNodeId ? mesh.nodes.find((n) => n.id === hostNodeId) : effectiveDaemonId ? mesh.nodes.find((n) => n.daemonId && daemonIdsEquivalent(n.daemonId, effectiveDaemonId)) : void 0;
+      if (hostNode) {
+        for (const node of mesh.nodes) {
+          if (node.role === "host" && node !== hostNode) node.role = void 0;
+        }
+        hostNode.role = "host";
+        if (!mesh.meshHost.hostNodeId) mesh.meshHost.hostNodeId = hostNode.id;
+      }
+      mesh.updatedAt = now;
+      saveMeshConfig(config2);
+      return {
+        mesh,
+        meshHost: mesh.meshHost,
+        applied: true,
+        reason: "pinned",
+        ...mesh.meshHost.hostDaemonId ? { hostDaemonId: mesh.meshHost.hostDaemonId } : {},
+        ...mesh.meshHost.hostNodeId ? { hostNodeId: mesh.meshHost.hostNodeId } : {}
+      };
+    }
     function markMeshHostPairingJoined(meshId, opts) {
       const config2 = loadMeshConfig();
       const mesh = config2.meshes.find((m) => m.id === meshId);
@@ -36670,6 +36755,12 @@ ${error48.message || ""}`;
         worktreeBootstrap: opts.worktreeBootstrap,
         role: opts.role
       };
+      const pinnedHostDaemonId = typeof mesh.meshHost?.hostDaemonId === "string" ? mesh.meshHost.hostDaemonId.trim() : "";
+      const anchorMissing = !(typeof mesh.meshHost?.hostNodeId === "string" && mesh.meshHost.hostNodeId.trim());
+      if (!node.role && anchorMissing && pinnedHostDaemonId && mesh.meshHost?.role !== "member" && node.daemonId && daemonIdsEquivalent(node.daemonId, pinnedHostDaemonId) && !mesh.nodes.some((n) => n.role === "host")) {
+        node.role = "host";
+        mesh.meshHost = { ...mesh.meshHost || createDefaultMeshHostMetadata(), hostNodeId: node.id };
+      }
       mesh.nodes.push(node);
       mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       saveMeshConfig(config2);
@@ -39392,9 +39483,20 @@ Next step: ${nextStep}`;
           }
           continue;
         }
+        if (validated.intendedFor && !validated.intendedFor.sessionId && daemonIdsEquivalent(validated.intendedFor.daemonId, drainer.daemonId)) {
+          const liveSessions = ctx.countLiveCoordinatorSessions?.(validated.intendedFor.daemonId) ?? 0;
+          if (liveSessions > 1) {
+            warnV2Once(
+              `${event.meshId}::${eventId}::ambiguous-unicast`,
+              `v2 unicast ${event.event} on mesh ${event.meshId} carries NO coordinator session but ${liveSessions} coordinator sessions are live on ${validated.intendedFor.daemonId} \u2014 delivery is first-come-first-served and may reach the wrong coordinator. Delivered to ${coordinatorIdentityKey(drainer)}. The EMITTING path must stamp targetCoordinatorSessionId.`
+            );
+            bump("v2AmbiguousUnicastDelivered");
+          }
+        }
         if (validated.intendedFor && identityDeliversTo(validated.intendedFor, drainer)) {
           ctx.batchSeen.add(eventId);
           bump("v2Delivered");
+          LOG2.debug("MeshEventsV2", `unicast ${event.event} (mesh ${event.meshId}, eventId ${eventId}) delivered to ${coordinatorIdentityKey(drainer)}; intendedFor=${coordinatorIdentityKey(validated.intendedFor)}`);
           kept.push(event);
           continue;
         }
@@ -39409,6 +39511,7 @@ Next step: ${nextStep}`;
           kept.push(event);
           continue;
         }
+        LOG2.debug("MeshEventsV2", `unicast ${event.event} (mesh ${event.meshId}, eventId ${eventId}) NOT delivered to ${coordinatorIdentityKey(drainer)}; intendedFor=${validated.intendedFor ? coordinatorIdentityKey(validated.intendedFor) : "none"} \u2014 left for its own drainer`);
         bump("v2RoutedAway");
       }
       return kept;
@@ -39861,7 +39964,12 @@ Next step: ${nextStep}`;
       try {
         const store = MeshRuntimeStore.getInstance();
         if (store.pendingEventCount(meshId) > 0) {
-          for (const row of store.drainPendingEvents(meshId, daemonIds.length > 0 ? daemonIds : void 0, onlyEvents ? { onlyEvents } : void 0)) {
+          const drainedBy = drainer ? JSON.stringify(drainer) : null;
+          for (const row of store.drainPendingEvents(
+            meshId,
+            daemonIds.length > 0 ? daemonIds : void 0,
+            { ...onlyEvents ? { onlyEvents } : {}, drainedBy }
+          )) {
             const event = row.payload;
             if (event) pushUnique(event);
           }
@@ -39900,7 +40008,8 @@ Next step: ${nextStep}`;
       const routed = routeV2EventsForDrainer(merged, drainer, {
         alreadyDrained: (eventId) => priorDrainedEventIds.has(eventId),
         batchSeen: /* @__PURE__ */ new Set(),
-        countMetrics: true
+        countMetrics: true,
+        ...opts?.countLiveCoordinatorSessions ? { countLiveCoordinatorSessions: opts.countLiveCoordinatorSessions } : {}
       });
       return reconcilePendingMeshCoordinatorEvents(meshId, routed);
     }
@@ -40120,6 +40229,11 @@ Next step: ${nextStep}`;
           /** unicast events re-attributed to the drainer via daemon-core match (a
            *  coordinatorRunId change orphaned them). */
           v2ReattributedToDrainer: 0,
+          /** REFINE-EVENT-SESSION-SCOPED-UNICAST: unicast events delivered while addressed only
+           *  at DAEMON granularity (no sessionId in intendedFor) even though >1 coordinator
+           *  session was live on that daemon — i.e. delivered by race, not by address. Non-zero
+           *  here names an emit path that still fails to stamp targetCoordinatorSessionId. */
+          v2AmbiguousUnicastDelivered: 0,
           /** v1 (unversioned) events passed through as broadcast (rollout baseline). */
           v1BroadcastAccepted: 0,
           /** T6 enforce: v2 events that FAILED validation and were QUARANTINED (held back
@@ -41878,7 +41992,15 @@ Next step: ${nextStep}`;
                 event_id TEXT,
                 scope TEXT,
                 dispatched_by TEXT,
-                intended_for TEXT
+                intended_for TEXT,
+                -- REFINE-EVENT-SESSION-SCOPED-UNICAST: WHO consumed this row. The ledger
+                -- previously recorded only THAT an event was drained, never by which
+                -- coordinator identity \u2014 so a mis-delivered unicast (a sibling session
+                -- consuming another coordinator's event) left no evidence and had to be
+                -- inferred. Written at drain time as the JSON-serialized drainer
+                -- CoordinatorIdentity. NULL on rows drained before this column existed
+                -- and on any drain whose caller passed no identity (daemon-level drain).
+                drained_by TEXT
             );
 
             CREATE INDEX IF NOT EXISTS idx_mesh_pending_events_mesh_drained
@@ -42124,7 +42246,7 @@ Next step: ${nextStep}`;
                 this.db.exec(`ALTER TABLE mesh_missions ADD COLUMN close_candidate_emitted_at TEXT`);
               }
               const pendingCols = this.tableColumns("mesh_pending_events");
-              for (const col of ["protocol_version", "event_id", "scope", "dispatched_by", "intended_for"]) {
+              for (const col of ["protocol_version", "event_id", "scope", "dispatched_by", "intended_for", "drained_by"]) {
                 if (!pendingCols.has(col)) {
                   this.db.exec(`ALTER TABLE mesh_pending_events ADD COLUMN ${col} TEXT`);
                 }
@@ -43393,8 +43515,8 @@ Next step: ${nextStep}`;
               const ids = rows.map((r) => r.id);
               const now = Date.now();
               this.db.prepare(
-                `UPDATE mesh_pending_events SET drained = 1, drained_at = ? WHERE id IN (${ids.map(() => "?").join(",")})`
-              ).run(now, ...ids);
+                `UPDATE mesh_pending_events SET drained = 1, drained_at = ?, drained_by = ? WHERE id IN (${ids.map(() => "?").join(",")})`
+              ).run(now, opts?.drainedBy ?? null, ...ids);
               return rows.map((r) => ({
                 id: r.id,
                 event: r.event,
@@ -43428,6 +43550,30 @@ Next step: ${nextStep}`;
               })()
             }));
           }
+          /**
+           * REFINE-EVENT-SESSION-SCOPED-UNICAST — drain attribution audit. Returns the most
+           * recent pending-event rows for a mesh with WHO drained each one, so a suspected
+           * mis-delivery ("my refine result went to another coordinator session") is answered
+           * from the ledger instead of inferred from timing. `drainedBy` is the serialized
+           * drainer CoordinatorIdentity, or null when the row is still queued, was drained
+           * before this column existed, or was drained by a caller that passed no identity.
+           */
+          recentDrainedPendingEvents(meshId, limit = 100) {
+            const rows = this.db.prepare(
+              `SELECT id, event, scope, intended_for, drained_by, drained, queued_at, drained_at
+             FROM mesh_pending_events WHERE mesh_id = ? ORDER BY queued_at DESC LIMIT ?`
+            ).all(meshId, Math.max(1, limit));
+            return rows.map((r) => ({
+              id: r.id,
+              event: r.event,
+              scope: r.scope ?? null,
+              intendedFor: r.intended_for ?? null,
+              drainedBy: r.drained_by ?? null,
+              drained: r.drained === 1,
+              queuedAt: r.queued_at,
+              drainedAt: r.drained_at ?? null
+            }));
+          }
           hasPendingEventFingerprint(meshId, fingerprint) {
             const row = this.db.prepare(
               "SELECT 1 FROM mesh_pending_events WHERE mesh_id = ? AND fingerprint = ? AND drained = 0 LIMIT 1"
@@ -43602,7 +43748,7 @@ Next step: ${nextStep}`;
           requeueDrainedPendingEventByFingerprint(meshId, fingerprint) {
             if (!fingerprint) return false;
             const changes = this.db.prepare(
-              `UPDATE mesh_pending_events SET drained = 0, drained_at = NULL
+              `UPDATE mesh_pending_events SET drained = 0, drained_at = NULL, drained_by = NULL
              WHERE mesh_id = ? AND fingerprint = ? AND drained = 1`
             ).run(meshId, fingerprint).changes;
             if (changes > 0) this.maybeCheckpointWal();
@@ -61514,7 +61660,15 @@ ${cleanBody}`;
       try {
         pendingEvents = drainPendingMeshCoordinatorEvents(
           meshId,
-          drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId
+          drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
+          {
+            // AMBIGUOUS-UNICAST guard (REFINE-EVENT-SESSION-SCOPED-UNICAST): observability
+            // only — it warns when a session-less unicast event is delivered while several
+            // coordinator sessions are live and racing for it. Never changes delivery, so
+            // an event can't be stranded by it. targetCoordinators is this daemon's live
+            // coordinator set for the mesh, which is exactly the racing population.
+            countLiveCoordinatorSessions: () => new Set(targetCoordinators.map((c) => c.sessionId).filter(Boolean)).size
+          }
         );
       } catch (e) {
         LOG2.warn("MeshReconcile", `Drain failed for mesh ${meshId}: ${e?.message || e}`);
@@ -101143,7 +101297,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
         return { success: true, mesh: meshRecord.mesh, sourceOfTruth };
       },
-      create_mesh: async (_ctx, args) => {
+      create_mesh: async (ctx, args) => {
         const name = typeof args?.name === "string" ? args.name.trim() : "";
         const repoIdentity = typeof args?.repoIdentity === "string" ? args.repoIdentity.trim() : "";
         const repoRemoteUrl = typeof args?.repoRemoteUrl === "string" ? args.repoRemoteUrl.trim() : void 0;
@@ -101152,12 +101306,71 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         try {
           const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           const meshHost = args?.meshHost && typeof args.meshHost === "object" && !Array.isArray(args.meshHost) ? args.meshHost : void 0;
-          const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch, policy: args?.policy, meshHost });
+          const requestedHostDaemonId = typeof args?.hostDaemonId === "string" && args.hostDaemonId.trim() ? args.hostDaemonId.trim() : ctx.deps.statusInstanceId || "";
+          const mesh = createMesh2({
+            name,
+            repoIdentity,
+            repoRemoteUrl,
+            defaultBranch,
+            policy: args?.policy,
+            meshHost,
+            ...requestedHostDaemonId ? { hostDaemonId: requestedHostDaemonId } : {}
+          });
           return { success: true, mesh };
         } catch (e) {
           return { success: false, error: e.message };
         }
       },
+      // HOST-PIN-WRITER — establish this mesh's host daemon as a DELIBERATE operator act.
+      //
+      // The dashboard's first-setup flow lets the operator pick which connected daemon
+      // becomes the host; this is the command that actually persists that choice. It is a
+      // separate surface from coordinator launch on purpose: the pin is effectively
+      // permanent ("Fixed when the mesh is created — it cannot be reassigned here"), so it
+      // must not be an incidental side effect of a button whose stated job is launching a
+      // session. A mis-click must not permanently re-home a mesh.
+      //
+      // Reassignment to a DIFFERENT daemon is refused unless the caller passes
+      // force:true — the mutator returns code 'host_already_pinned' and changes nothing.
+      // Re-pinning the same daemon is a no-op, so retries/races are safe.
+      set_mesh_host: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const hostDaemonId = typeof args?.hostDaemonId === "string" ? args.hostDaemonId.trim() : "";
+        const hostNodeId = typeof args?.hostNodeId === "string" ? args.hostNodeId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        if (!hostDaemonId && !hostNodeId) return { success: false, error: "hostDaemonId or hostNodeId required" };
+        try {
+          const { setMeshHostPin: setMeshHostPin2, getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const result = setMeshHostPin2(meshId, {
+            ...hostDaemonId ? { hostDaemonId } : {},
+            ...hostNodeId ? { hostNodeId } : {},
+            force: args?.force === true
+          });
+          if (!result) return { success: false, error: "Mesh not found" };
+          if (!result.applied && result.reason !== "already_pinned_same") {
+            return {
+              success: false,
+              code: result.reason,
+              error: result.reason === "host_already_pinned" ? `Mesh host is already pinned to ${result.hostDaemonId}. Pass force:true to reassign it.` : result.reason === "not_host_role" ? "This daemon joined the mesh as a member; its host lives on the daemon it paired with." : "hostDaemonId or hostNodeId required",
+              meshId,
+              meshHost: resolveMeshHostStatus(result.mesh)
+            };
+          }
+          const fresh = getMesh2(meshId) || result.mesh;
+          if (ctx.getCachedInlineMesh(meshId)) ctx.inlineMeshCache.set(meshId, fresh);
+          ctx.invalidateAggregateMeshStatus(meshId);
+          return {
+            success: true,
+            code: result.reason,
+            meshId,
+            applied: result.applied,
+            meshHost: resolveMeshHostStatus(fresh),
+            mesh: fresh
+          };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      },
       update_mesh: async (ctx, args) => {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
@@ -103102,6 +103315,26 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_mesh_coordinator();
     init_dist();
     init_repo_mesh_types();
+    async function backfillMeshHostPinAfterLaunch(opts) {
+      try {
+        const existingPin = typeof opts.mesh?.meshHost?.hostDaemonId === "string" ? opts.mesh.meshHost.hostDaemonId.trim() : "";
+        if (existingPin) return;
+        const { getMesh: getMesh2, setMeshHostPin: setMeshHostPin2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+        if (!getMesh2(opts.meshId)) return;
+        const nodeDaemonId = typeof opts.coordinatorNode?.daemonId === "string" && opts.coordinatorNode.daemonId.trim() ? opts.coordinatorNode.daemonId.trim() : typeof opts.coordinatorNode?.daemon_id === "string" && opts.coordinatorNode.daemon_id.trim() ? opts.coordinatorNode.daemon_id.trim() : opts.localDaemonId || "";
+        const nodeId = String(normalizeMeshNodeId(opts.coordinatorNode) || "");
+        if (!nodeDaemonId && !nodeId) return;
+        const result = setMeshHostPin2(opts.meshId, {
+          ...nodeDaemonId ? { hostDaemonId: nodeDaemonId } : {},
+          ...nodeId ? { hostNodeId: nodeId } : {}
+        });
+        if (result?.applied) {
+          LOG2.info("MeshCoordinator", `Pinned mesh ${opts.meshId} host to ${result.hostDaemonId || nodeDaemonId} (node ${result.hostNodeId || nodeId}) after coordinator launch`);
+        }
+      } catch (error48) {
+        LOG2.warn("MeshCoordinator", `Host pin backfill skipped for mesh ${opts.meshId}: ${error48?.message || String(error48)}`);
+      }
+    }
     var meshCoordinatorLaunchHandlers = {
       launch_mesh_coordinator: async (ctx, args) => {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
@@ -103461,6 +103694,12 @@ ${ptyResult.output.slice(-2e3)}`);
               });
             } catch {
             }
+            await backfillMeshHostPinAfterLaunch({
+              meshId,
+              mesh,
+              coordinatorNode,
+              localDaemonId: ctx.deps.statusInstanceId
+            });
             return {
               success: true,
               meshId,
@@ -103659,6 +103898,12 @@ ${ptyResult.output.slice(-2e3)}`);
             });
           } catch {
           }
+          await backfillMeshHostPinAfterLaunch({
+            meshId,
+            mesh,
+            coordinatorNode,
+            localDaemonId: ctx.deps.statusInstanceId
+          });
           return {
             success: true,
             meshId,
@@ -106061,6 +106306,7 @@ ${mergeTreeErr?.stderr || ""}`;
         ...args.completedAt ? { completedAt: args.completedAt } : {},
         ...args.retryOfJobId ? { retryOfJobId: args.retryOfJobId } : {},
         ...args.coordinatorDaemonId ? { targetCoordinatorDaemonId: args.coordinatorDaemonId } : {},
+        ...args.coordinatorSessionId ? { targetCoordinatorSessionId: args.coordinatorSessionId } : {},
         eventDelivery: { pendingEvents: true, ledger: true },
         evidence: {
           pendingEventsCommand: "get_pending_mesh_events",
@@ -106159,9 +106405,23 @@ ${mergeTreeErr?.stderr || ""}`;
         nodeLabel: handle.targetNodeId,
         nodeId: handle.targetNodeId,
         workspace: handle.workspace,
-        metadataEvent,
+        metadataEvent: {
+          ...metadataEvent,
+          // REFINE-EVENT-SESSION-SCOPED-UNICAST: mirror the session INSIDE
+          // metadataEvent too. handleMeshForwardEvent reads the coordinator session
+          // anchor from `metadataEvent.meshCoordinatorSessionId` (a top-level field
+          // alone is dropped when the event crosses a machine boundary), so this is
+          // what survives the P2P relay for a remote-executing refine.
+          ...handle.targetCoordinatorSessionId ? { meshCoordinatorSessionId: handle.targetCoordinatorSessionId } : {}
+        },
         queuedAt: Date.now(),
-        ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {}
+        ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {},
+        // THE FIX: address the terminal event to the requesting coordinator SESSION,
+        // not just its daemon. stampPendingEventV2 folds this into the v2 unicast
+        // `intendedFor`, so identityDeliversTo's both-sides-session branch excludes a
+        // sibling coordinator session on the same daemon. Absent (legacy requester) →
+        // session-less intendedFor → daemon-level delivery exactly as before.
+        ...handle.targetCoordinatorSessionId ? { targetCoordinatorSessionId: handle.targetCoordinatorSessionId } : {}
       };
       if (typeof self.deps.instanceManager?.getByCategory === "function") {
         const forwarded = handleMeshForwardEvent(
@@ -106185,6 +106445,14 @@ ${mergeTreeErr?.stderr || ""}`;
             // re-queued event self-fallbacks to THIS (the executing/worker)
             // daemon and the real coordinator's drain excludes it.
             ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {},
+            // REFINE-EVENT-SESSION-SCOPED-UNICAST: carry the SESSION half of the
+            // return address across the relay as well. buildRelayMetadataEvent
+            // reads meshCoordinatorSessionId (falling back to
+            // targetCoordinatorSessionId), so both spellings are supplied.
+            ...handle.targetCoordinatorSessionId ? {
+              targetCoordinatorSessionId: handle.targetCoordinatorSessionId,
+              meshCoordinatorSessionId: handle.targetCoordinatorSessionId
+            } : {},
             ...slimResult ? { result: slimResult } : {}
           }
         );
@@ -107609,6 +107877,7 @@ ${e?.stderr || ""}`;
         startedAt: args.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
         ...args.completedAt ? { completedAt: args.completedAt } : {},
         ...args.coordinatorDaemonId ? { targetCoordinatorDaemonId: args.coordinatorDaemonId } : {},
+        ...args.coordinatorSessionId ? { targetCoordinatorSessionId: args.coordinatorSessionId } : {},
         eventDelivery: { pendingEvents: true, ledger: true },
         evidence: {
           pendingEventsCommand: "get_pending_mesh_events",
@@ -107638,9 +107907,16 @@ ${e?.stderr || ""}`;
         meshId: handle.meshId,
         nodeLabel: handle.batchLabel,
         nodeId: handle.batchLabel,
-        metadataEvent,
+        metadataEvent: {
+          ...metadataEvent,
+          // REFINE-EVENT-SESSION-SCOPED-UNICAST — see queueRefineJobEvent.
+          ...handle.targetCoordinatorSessionId ? { meshCoordinatorSessionId: handle.targetCoordinatorSessionId } : {}
+        },
         queuedAt: Date.now(),
-        ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {}
+        ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {},
+        // THE FIX (batch half) — address the batch terminal event to the requesting
+        // coordinator SESSION so a sibling session cannot consume it.
+        ...handle.targetCoordinatorSessionId ? { targetCoordinatorSessionId: handle.targetCoordinatorSessionId } : {}
       };
       if (typeof self.deps.instanceManager?.getByCategory === "function") {
         const forwarded = handleMeshForwardEvent(
@@ -107658,6 +107934,12 @@ ${e?.stderr || ""}`;
             // the sessionless batch job's terminal event must stay targeted
             // at the originating coordinator, not self-fallback to this daemon.
             ...handle.targetCoordinatorDaemonId ? { targetCoordinatorDaemonId: handle.targetCoordinatorDaemonId } : {},
+            // REFINE-EVENT-SESSION-SCOPED-UNICAST — session half of the return
+            // address, both spellings (see queueRefineJobEvent).
+            ...handle.targetCoordinatorSessionId ? {
+              targetCoordinatorSessionId: handle.targetCoordinatorSessionId,
+              meshCoordinatorSessionId: handle.targetCoordinatorSessionId
+            } : {},
             ...result ? { result } : {}
           }
         );
@@ -107730,7 +108012,10 @@ ${e?.stderr || ""}`;
         completedAt,
         jobId: handle.jobId,
         interactionId: handle.interactionId,
-        coordinatorDaemonId: handle.targetCoordinatorDaemonId
+        coordinatorDaemonId: handle.targetCoordinatorDaemonId,
+        // REFINE-EVENT-SESSION-SCOPED-UNICAST — carry the requester's session onto the
+        // terminal batch handle (see the single-node path).
+        coordinatorSessionId: handle.targetCoordinatorSessionId
       });
       const terminal = { ...terminalHandle, result: normalizedResult };
       self.terminalRefineBatchJobs.set(key2, terminal);
@@ -107764,7 +108049,8 @@ ${e?.stderr || ""}`;
         rationale: planRecord.orderingRationale
       };
       const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : self.deps.statusInstanceId || void 0;
-      const handle = buildRefineBatchJobHandle(self, { meshId, nodeIds, order, coordinatorDaemonId });
+      const coordinatorSessionId = typeof args?.coordinatorSessionId === "string" && args.coordinatorSessionId.trim() ? args.coordinatorSessionId.trim() : void 0;
+      const handle = buildRefineBatchJobHandle(self, { meshId, nodeIds, order, coordinatorDaemonId, coordinatorSessionId });
       self.runningRefineBatchJobs.set(key2, handle);
       await appendRefineBatchJobLedger(self, "task_dispatched", handle);
       queueRefineBatchJobEvent(self, "refine:accepted", handle);
@@ -107855,7 +108141,12 @@ ${e?.stderr || ""}`;
         interactionId: handle.interactionId,
         retryOfJobId: handle.retryOfJobId,
         node: { daemonId: handle.targetDaemonId, workspace: handle.workspace },
-        coordinatorDaemonId: handle.targetCoordinatorDaemonId
+        coordinatorDaemonId: handle.targetCoordinatorDaemonId,
+        // REFINE-EVENT-SESSION-SCOPED-UNICAST: carry the requester's session from the
+        // accepted handle onto the TERMINAL handle. Dropping it here would leave the
+        // completed/failed event — the one the coordinator actually waits on — back at
+        // daemon-level addressing, i.e. the original defect.
+        coordinatorSessionId: handle.targetCoordinatorSessionId
       });
       const terminal = { ...terminalHandle, result: normalizedResult };
       self.terminalRefineJobs.set(key2, terminal);
@@ -107875,7 +108166,8 @@ ${e?.stderr || ""}`;
       if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
       if (!node.isLocalWorktree || !node.workspace) return { success: false, error: `Refinery requires a local worktree node` };
       const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : self.deps.statusInstanceId || void 0;
-      const handle = buildRefineJobHandle(self, { meshId, nodeId, node, retryOfJobId: terminal?.jobId, coordinatorDaemonId });
+      const coordinatorSessionId = typeof args?.coordinatorSessionId === "string" && args.coordinatorSessionId.trim() ? args.coordinatorSessionId.trim() : void 0;
+      const handle = buildRefineJobHandle(self, { meshId, nodeId, node, retryOfJobId: terminal?.jobId, coordinatorDaemonId, coordinatorSessionId });
       self.runningRefineJobs.set(key2, handle);
       await appendRefineJobLedger(self, "task_dispatched", handle);
       queueRefineJobEvent(self, "refine:accepted", handle);