@adhdev/daemon-core 0.9.82-rc.451 → 0.9.82-rc.453

package/package.json

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

package/src/mesh/mesh-active-work.ts

@@ -2,7 +2,7 @@ import type { MeshLedgerEntry } from './mesh-ledger.js';
 import { appendLedgerEntry } from './mesh-ledger.js';
 import type { MeshWorkQueueEntry, DirectDispatchRecord } from './mesh-work-queue.js';
 import { deleteDirectDispatchesByTaskId } from './mesh-work-queue.js';
-import { meshNodeIdMatches } from '@adhdev/mesh-shared';
+import { meshNodeIdMatches, daemonIdsEquivalent, sessionIdsEquivalent } from '@adhdev/mesh-shared';
 
 export type MeshActiveWorkSource = 'queue' | 'direct';
 export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
@@ -128,9 +128,9 @@ function sessionStatusFromNodes(nodes: any[] | undefined, nodeId?: string, sessi
         if (value && typeof value === 'object') candidates.push(value);
     }
     const session = candidates.find(item => {
-        if (typeof item === 'string') return item === sessionId;
+        if (typeof item === 'string') return sessionIdsEquivalent(item, sessionId);
         const id = readString(item?.id) || readString(item?.sessionId) || readString(item?.session_id) || readString(item?.runtimeSessionId) || readString(item?.instanceId);
-        return id === sessionId;
+        return sessionIdsEquivalent(id, sessionId);
     });
     if (!session) return { staleReason: 'direct task session is not present in live session records' };
     if (typeof session === 'string') return {};
@@ -158,8 +158,10 @@ function terminalMatchesDispatch(terminal: MeshLedgerEntry, dispatch: MeshLedger
     const terminalTaskId = readString(terminal.payload?.taskId);
     if (terminalTaskId && terminalTaskId === taskId) return true;
     if (terminalTaskId && terminalTaskId !== taskId) return false;
-    if (dispatch.sessionId && terminal.sessionId === dispatch.sessionId) return true;
-    return Boolean(dispatch.nodeId && terminal.nodeId === dispatch.nodeId && !dispatch.sessionId);
+    if (dispatch.sessionId && sessionIdsEquivalent(terminal.sessionId, dispatch.sessionId)) return true;
+    // Node ids can carry interchangeable daemon-id forms (bare `mach_X` vs
+    // `daemon_mach_X`); compare under the canonical machine core, not raw `===`.
+    return Boolean(dispatch.nodeId && daemonIdsEquivalent(terminal.nodeId, dispatch.nodeId) && !dispatch.sessionId);
 }
 
 function statusFromTerminal(entry: MeshLedgerEntry): MeshActiveWorkStatus {

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

@@ -15,7 +15,7 @@ import { enqueueUnresolvedDelegateForward, peekUnresolvedDelegateForwards, ackUn
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { getLastDisplayMessage } from '../status/snapshot.js';
 import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
-import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, type MeshNodeIdentified } from '@adhdev/mesh-shared';
+import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, sessionIdsEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
     hasDispatchAfterTerminal,
@@ -204,10 +204,9 @@ function hasRecentIntentionalCleanupStop(meshId: string, sessionId?: string, nod
         const timestamp = new Date(entry.timestamp).getTime();
         if (!Number.isNaN(timestamp) && timestamp < cutoff) break;
         if (!isIntentionalCleanupStopEntry(entry)) continue;
-        // SESSION-ID IS SINGLE-FORM: a session id is one canonical UUID (crypto.randomUUID
-        // in the provider instance), carried verbatim across daemons — no serialization
-        // variants like node/daemon ids. Exact `===` is correct; no equivalence helper.
-        if (sessionId && entry.sessionId === sessionId) return true;
+        // Session ids are single-form; sessionIdsEquivalent is the one canonical
+        // exact-match predicate (see its doc for why no form expansion is needed).
+        if (sessionId && sessionIdsEquivalent(entry.sessionId, sessionId)) 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.
@@ -439,9 +438,9 @@ function supersedesTruncatedTerminalSummary(args: {
 // task surfaces as status='unknown' / terminalKind=null in computeMeshTaskStats.
 function resolveActiveDirectDispatchTaskId(meshId: string, sessionId: string): string | undefined {
     try {
-        // SESSION-ID IS SINGLE-FORM (canonical crypto.randomUUID, carried verbatim across
-        // daemons) — exact `===` filter is correct; no node-id-style form normalization.
-        const matches = getActiveDirectDispatches(meshId).filter(d => d.sessionId === sessionId);
+        // Session ids are single-form; sessionIdsEquivalent is the one canonical
+        // exact-match predicate — no node-id-style form normalization needed.
+        const matches = getActiveDirectDispatches(meshId).filter(d => sessionIdsEquivalent(d.sessionId, sessionId));
         if (!matches.length) return undefined;
         // getActiveDirectDispatches returns rows ordered by dispatched_at ASC; the last is
         // the most recent dispatch (the re-dispatch / nudge whose completion this is).
@@ -1747,7 +1746,7 @@ export function flushPendingForMeshIdleCoordinators(components: DaemonComponents
     for (const pending of pendingEvents) {
         const wantSession = readNonEmptyString(pending.targetCoordinatorSessionId);
         const targets = wantSession
-            ? idleCoordinators.filter(c => c.sessionId === wantSession)
+            ? idleCoordinators.filter(c => sessionIdsEquivalent(c.sessionId, wantSession))
             : idleCoordinators;
         // Not deliverable into an idle target here (wrong/absent session), or a message-less
         // lifecycle event (agent:ready / generating_started carry no coordinatorMessage and
@@ -1826,7 +1825,7 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
                         let hasDirectDispatch = false;
                         try {
                             hasDirectDispatch =
-                                getActiveDirectDispatches(coordinatorMeshId).some(d => d.sessionId === flushInstanceId)
+                                getActiveDirectDispatches(coordinatorMeshId).some(d => sessionIdsEquivalent(d.sessionId, flushInstanceId))
                                 || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, flushInstanceId);
                         } catch { /* best-effort */ }
                         if (!hasDirectDispatch) return;

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

@@ -4,7 +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, isWeakCompletionEvidence, buildMeshSystemMessage } from './mesh-events-utils.js';
-import { meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared';
+import { meshNodeIdMatches, sessionIdsEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 
 // ---------------------------------------------------------------------------
 // Stale direct-dispatch detection & transcript reconciliation
@@ -42,7 +42,7 @@ export function findRecentTerminalLedgerEvidence(args: {
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
         if (entry.kind !== 'task_completed' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') continue;
-        if (args.sessionId && entry.sessionId === args.sessionId) {
+        if (args.sessionId && sessionIdsEquivalent(entry.sessionId, args.sessionId)) {
             return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
         }
         // Normalized node-id match (P4): a ledger entry may store its node id as `nodeId`
@@ -70,7 +70,7 @@ export function hasDispatchAfterTerminal(meshId: string, sessionId: string, term
             if (entry.id === terminalId) pastTerminal = true;
             continue;
         }
-        if (entry.kind === 'task_dispatched' && entry.sessionId === sessionId) return true;
+        if (entry.kind === 'task_dispatched' && sessionIdsEquivalent(entry.sessionId, sessionId)) return true;
     }
     return false;
 }
@@ -82,7 +82,7 @@ export function hasUnterminalDirectDispatchLedgerEntry(meshId: string, sessionId
     const entries = readLedgerEntries(meshId, { tail: 200 });
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
-        if (entry.sessionId !== sessionId) continue;
+        if (!sessionIdsEquivalent(entry.sessionId, sessionId)) continue;
         if (entry.kind === 'task_completed' || entry.kind === 'task_failed' || entry.kind === 'task_stalled') {
             return false;
         }
@@ -109,7 +109,7 @@ export function findTerminalLedgerEvidenceForTask(args: {
         const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
         if (terminalTaskId !== taskId) continue;
         if (entry.kind === 'task_completed' && isWeakCompletionEvidence(entry.payload)) continue;
-        if (args.sessionId && entry.sessionId && entry.sessionId !== args.sessionId) continue;
+        if (args.sessionId && entry.sessionId && !sessionIdsEquivalent(entry.sessionId, args.sessionId)) continue;
         if (!args.sessionId && args.nodeId && entry.nodeId && !meshNodeIdMatches(entry as unknown as MeshNodeIdentified, args.nodeId)) continue;
         return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
     }
@@ -127,7 +127,7 @@ function findDirectDispatchLedgerEntry(args: {
         if (entry.kind !== 'task_dispatched') continue;
         const payloadTaskId = readNonEmptyString(entry.payload?.taskId);
         if (payloadTaskId !== args.taskId) continue;
-        if (args.sessionId && entry.sessionId && entry.sessionId !== args.sessionId) continue;
+        if (args.sessionId && entry.sessionId && !sessionIdsEquivalent(entry.sessionId, args.sessionId)) continue;
         return {
             id: entry.id,
             timestamp: entry.timestamp,
@@ -172,7 +172,7 @@ function hasTerminalLedgerAfterDispatch(args: {
         const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
         if (terminalTaskId && terminalTaskId === args.taskId) return true;
         if (terminalTaskId && terminalTaskId !== args.taskId) continue;
-        if (args.sessionId && entry.sessionId === args.sessionId) return true;
+        if (args.sessionId && sessionIdsEquivalent(entry.sessionId, args.sessionId)) return true;
     }
     return false;
 }

package/src/mesh/mesh-ledger.ts

@@ -17,6 +17,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, renameSy
 import { join } from 'path';
 import { randomUUID } from 'crypto';
 import { getConfigDir } from '../config/config.js';
+import { daemonIdsEquivalent, sessionIdsEquivalent } from '@adhdev/mesh-shared';
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 // ─── Types ──────────────────────────────────────
@@ -1224,7 +1225,7 @@ export function getSessionRecoveryContext(
         if (!failureCountDone) {
             if (ts < recentWindow) {
                 failureCountDone = true;
-            } else if (opts.nodeId && e.nodeId !== opts.nodeId) {
+            } else if (opts.nodeId && !daemonIdsEquivalent(e.nodeId, opts.nodeId)) {
                 // Entry for a different node — skip for failure counting but continue scanning for dispatch
             } else if (e.kind === 'task_failed') {
                 if (!isIntentionalCleanupStopEntry(e)) consecutiveNodeFailures++;
@@ -1236,8 +1237,8 @@ export function getSessionRecoveryContext(
 
         // Dispatch search: find the last dispatch matching this session or node
         if (lastDispatch === null && e.kind === 'task_dispatched') {
-            if (opts.sessionId && e.sessionId === opts.sessionId) { lastDispatch = e; }
-            else if (!opts.sessionId && opts.nodeId && e.nodeId === opts.nodeId) { lastDispatch = e; }
+            if (opts.sessionId && sessionIdsEquivalent(e.sessionId, opts.sessionId)) { lastDispatch = e; }
+            else if (!opts.sessionId && opts.nodeId && daemonIdsEquivalent(e.nodeId, opts.nodeId)) { lastDispatch = e; }
         }
 
         // Stop once both tasks are done

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

@@ -14,7 +14,7 @@
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import { detectCLI } from '../detection/cli-detector.js';
 import { getGitRepoStatus } from '../git/git-status.js';
-import { normalizeGitStatus as sharedNormalizeGitStatus, pickBestTransitGitStatus as sharedPickBestTransitGitStatus, summarizeGitShape as sharedSummarizeGitShape, normalizeMeshNodeId, daemonIdsEquivalent, meshWorkspacesEquivalent } from '@adhdev/mesh-shared';
+import { normalizeGitStatus as sharedNormalizeGitStatus, pickBestTransitGitStatus as sharedPickBestTransitGitStatus, summarizeGitShape as sharedSummarizeGitShape, normalizeMeshNodeId, daemonIdsEquivalent, meshWorkspacesEquivalent, sessionIdsEquivalent } from '@adhdev/mesh-shared';
 import { LOG } from '../logging/logger.js';
 import { getSessionHostSurfaceKind } from '../session-host/runtime-surface.js';
 import { awaitWithWarmupDeadline, resolveWarmupDeadlineOpts } from '../mesh/mesh-warmup-deadline.js';
@@ -1606,7 +1606,7 @@ export async function hydrateInlineMeshDirectTruth(args: {
         const workspace = readStringValue(node?.workspace);
         const daemonId = readStringValue(node?.daemonId);
         const isSelfNode = Boolean(
-            nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId,
+            nodeId && selectedCoordinatorNodeId && daemonIdsEquivalent(nodeId, selectedCoordinatorNodeId),
         ) || Boolean(
             daemonId && (daemonIdsEquivalent(daemonId, args.localMachineId) || daemonIdsEquivalent(daemonId, args.statusInstanceId)),
         ) || Boolean(args.meshSource !== 'local_config' && nodeIndex === 0);
@@ -1720,7 +1720,7 @@ export async function hydrateInlineMeshDirectTruth(args: {
                 const nodeId = normalizeMeshNodeId(node) || `node_${nodeIndex}`;
                 const daemonId = readStringValue(node?.daemonId);
                 const isSelfNode = Boolean(
-                    nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId,
+                    nodeId && selectedCoordinatorNodeId && daemonIdsEquivalent(nodeId, selectedCoordinatorNodeId),
                 ) || Boolean(
                     daemonId && (daemonIdsEquivalent(daemonId, args.localMachineId) || daemonIdsEquivalent(daemonId, args.statusInstanceId)),
                 );
@@ -1794,7 +1794,10 @@ export function summarizeMeshSessionRecord(record: any): Record<string, unknown>
 
 function liveSessionRecordMatchesMeshNode(record: any, meshId: string, nodeId: string, nodeWorkspace = '', nodeIsMissingLocalWorktree = false): boolean {
     const recordNodeId = readStringValue(record?.meta?.meshNodeId);
-    if (!recordNodeId || recordNodeId !== nodeId) return false;
+    // A session's stamped meshNodeId and the node's id can carry interchangeable
+    // daemon-id forms (bare `mach_X` vs `daemon_mach_X`) — compare under the
+    // canonical machine core, not raw `!==` (CANON-IDENTITY class).
+    if (!recordNodeId || !daemonIdsEquivalent(recordNodeId, nodeId)) return false;
     if (nodeIsMissingLocalWorktree) return false;
     const recordWorkspace = readStringValue(record?.workspace);
     // Normalized compare (shared WTCLAIM rule): a base node and a co-located worktree
@@ -1855,7 +1858,7 @@ export function collectLiveMeshSessionRecords(args: {
         && !fs.existsSync(nodeWorkspace);
     const matches = args.liveSessionRecords.filter((record) => {
         const recordNodeId = readStringValue(record?.meta?.meshNodeId);
-        if (recordNodeId && recordNodeId !== args.nodeId) return false;
+        if (recordNodeId && !daemonIdsEquivalent(recordNodeId, args.nodeId)) return false;
         if (liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId, nodeWorkspace || '', nodeIsMissingLocalWorktree)) return true;
         if (nodeIsMissingLocalWorktree) return false;
         return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record, args.meshId, nodeWorkspace);
@@ -1865,7 +1868,7 @@ export function collectLiveMeshSessionRecords(args: {
         for (const record of args.liveSessionRecords) {
             if (readStringValue(record?.meta?.meshCoordinatorFor) !== args.meshId) continue;
             const sessionId = readStringValue(record?.sessionId);
-            if (sessionId && matches.some((entry) => readStringValue(entry?.sessionId) === sessionId)) continue;
+            if (sessionId && matches.some((entry) => sessionIdsEquivalent(readStringValue(entry?.sessionId), sessionId))) continue;
             matches.push(record);
         }
     }

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

@@ -15,7 +15,7 @@ import { traceMeshEventDrop } from './mesh-event-trace.js';
 import { awaitWithWarmupDeadline, resolveWarmupDeadlineOpts } from './mesh-warmup-deadline.js';
 import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy, resolveMaxParallelTasks, resolveMaxReadonlyParallelTasks } from '../repo-mesh-types.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
-import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalDaemonId, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
+import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalDaemonId, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, sessionIdsEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import { findTerminalLedgerEvidenceForTask, hasUnterminalDirectDispatchLedgerEntry } from './mesh-events-stale.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
 import { queuePendingMeshCoordinatorEvent, retractPendingDispatchBlockedEvent } from './mesh-events-pending.js';
@@ -834,7 +834,7 @@ function nodeHasActiveMeshWork(components: DaemonComponents, meshId: string, nod
         // task already running here — the CANON-IDENTITY duplicate dispatch.
         if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
         const sessionId = readNonEmptyString(state.instanceId);
-        if (currentSessionId && sessionId === currentSessionId && isIdleSessionState(state)) return false;
+        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState(state)) return false;
         return sessionStateLooksActive(state);
     });
 }
@@ -1042,7 +1042,7 @@ function activeProviderAssignedCount(meshId: string, nodeId: string, providerTyp
 }
 
 export function sessionHasActiveAssignment(meshId: string, sessionId: string): boolean {
-    if (getQueue(meshId, { status: ['assigned'] as any }).some(task => task.assignedSessionId === sessionId)) {
+    if (getQueue(meshId, { status: ['assigned'] as any }).some(task => sessionIdsEquivalent(task.assignedSessionId, sessionId))) {
         return true;
     }
     // Direct dispatches (mesh_send_task) are tracked in mesh_direct_dispatches, not the
@@ -1053,7 +1053,7 @@ export function sessionHasActiveAssignment(meshId: string, sessionId: string): b
     // session goes silently idle. This check runs before markSessionTerminal marks the
     // dispatch terminal, so the in-flight dispatch is still observable here.
     try {
-        if (getActiveDirectDispatches(meshId).some(d => d.sessionId === sessionId)) return true;
+        if (getActiveDirectDispatches(meshId).some(d => sessionIdsEquivalent(d.sessionId, sessionId))) return true;
         if (hasUnterminalDirectDispatchLedgerEntry(meshId, sessionId)) return true;
     } catch { /* best-effort — fall through to false */ }
     return false;

package/src/mesh/mesh-reconcile-loop.ts

@@ -57,7 +57,7 @@ import {
 } from './mesh-unresolved-forward-outbox.js';
 import { readNonEmptyString, readMeshCompletionSummary, buildMeshSystemMessage } from './mesh-events-utils.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
-import { expandDaemonIdForms, daemonIdsEquivalent } from '@adhdev/mesh-shared';
+import { expandDaemonIdForms, daemonIdsEquivalent, sessionIdsEquivalent } from '@adhdev/mesh-shared';
 import { getActiveDirectDispatches, getQueue, reclaimStrandedAssignedTask, updateTaskStatus } from './mesh-work-queue.js';
 import { readLedgerEntries } from './mesh-ledger.js';
 import { pruneStaleDirectDispatches } from './mesh-active-work.js';
@@ -753,11 +753,10 @@ function drainAndInjectIntoTargets(
         // (unchanged behaviour — regression-0 for the common case).
         const wantSession = readNonEmptyString(pending.targetCoordinatorSessionId);
         if (wantSession) {
-            // SESSION-ID IS SINGLE-FORM: a coordinator session id is one canonical
-            // UUID (crypto.randomUUID), carried verbatim end-to-end — no node/daemon-id
-            // style serialization variants. Exact `===` is the correct match; unlike
-            // the daemon-level set below it needs no equivalence helper.
-            const matched = targetCoordinators.filter(c => c.sessionId === wantSession);
+            // Session ids are single-form; sessionIdsEquivalent is the one canonical
+            // exact-match predicate — unlike the daemon-level set below it needs no
+            // form expansion.
+            const matched = targetCoordinators.filter(c => sessionIdsEquivalent(c.sessionId, wantSession));
             if (matched.length === 0) {
                 // The originating coordinator session is not deliverable on this daemon
                 // right now (gone, or modal-parked and excluded from targets). Strict mode

package/src/mesh/mesh-review-inbox.ts

@@ -12,6 +12,7 @@
 
 import type { MeshLedgerEntry } from './mesh-ledger.js';
 import { buildMeshAsyncRefineJobs } from './mesh-refine-status.js';
+import { daemonIdsEquivalent } from '@adhdev/mesh-shared';
 
 export type MeshReviewInboxReason = 'merge_candidate' | 'refine_blocked_review';
 
@@ -171,7 +172,7 @@ function resolveNodeEvidence(nodeId: string, ledgerEntries: MeshLedgerEntry[]):
 
     for (let i = ledgerEntries.length - 1; i >= 0; i--) {
         const entry = ledgerEntries[i];
-        if (entry.nodeId !== nodeId || !isTerminalLedgerKind(entry.kind)) continue;
+        if (!daemonIdsEquivalent(entry.nodeId, nodeId) || !isTerminalLedgerKind(entry.kind)) continue;
         const payload = readRecord(entry.payload) ?? {};
 
         if (!evidence.available) {
@@ -227,7 +228,7 @@ function resolveNodeEvidence(nodeId: string, ledgerEntries: MeshLedgerEntry[]):
 function hasBlockedReviewRefineResult(nodeId: string, ledgerEntries: MeshLedgerEntry[]): boolean {
     for (let i = ledgerEntries.length - 1; i >= 0; i--) {
         const entry = ledgerEntries[i];
-        if (entry.nodeId !== nodeId || !isTerminalLedgerKind(entry.kind)) continue;
+        if (!daemonIdsEquivalent(entry.nodeId, nodeId) || !isTerminalLedgerKind(entry.kind)) continue;
         const payload = readRecord(entry.payload) ?? {};
         if (payload.source !== 'refine_mesh_node_async_job') continue;
         const result = readRecord(payload.result);
@@ -275,7 +276,7 @@ export function deriveMeshReviewInboxItems(args: {
 
         const { evidence, transcriptHandle } = resolveNodeEvidence(nodeId, args.ledgerEntries);
         const activeRefineJob = [...refineJobs].reverse().find(job =>
-            (job.nodeId === nodeId || job.targetNodeId === nodeId)
+            (daemonIdsEquivalent(job.nodeId, nodeId) || daemonIdsEquivalent(job.targetNodeId, nodeId))
             && (job.status === 'accepted' || job.status === 'running'),
         ) ?? null;
 

package/src/mesh/mesh-routing.ts

@@ -4,7 +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';
+import { meshNodeIdMatches, sessionIdsEquivalent } from '@adhdev/mesh-shared';
 
 // ---------------------------------------------------------------------------
 // R1: single-source coordinator routing resolution
@@ -117,7 +117,7 @@ export function resolveWorkerDelegateRouting(
         let hasActiveDispatch = false;
         try {
             hasActiveDispatch =
-                getActiveDirectDispatches(coordinatorMeshId).some(d => d.sessionId === instanceId)
+                getActiveDirectDispatches(coordinatorMeshId).some(d => sessionIdsEquivalent(d.sessionId, instanceId))
                 || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, instanceId);
         } catch { /* best-effort */ }
         if (!hasActiveDispatch) return reject('coordinator_not_dispatch_target');

package/src/mesh/mesh-runtime-store.ts

@@ -4,7 +4,7 @@ import { LOG } from '../logging/logger.js';
 import { loadBetterSqlite3 } from '../system/load-better-sqlite3.js';
 import { getLedgerDir } from './mesh-ledger.js';
 import { nodeSatisfiesRequiredTags, isTaskReadonly } from './mesh-work-queue.js';
-import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms } from '@adhdev/mesh-shared';
+import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, sessionIdsEquivalent } from '@adhdev/mesh-shared';
 import type { MeshTaskStatus, MeshWorkQueueEntry } from './mesh-work-queue.js';
 import type BetterSqlite3 from 'better-sqlite3';
 import type { Database as DatabaseHandle } from 'better-sqlite3';
@@ -795,13 +795,11 @@ export class MeshRuntimeStore {
             // an empty session. Accept the candidate when the target resolves to the
             // same node under ANY equivalent form; keep targetSessionId an exact match.
             const targetMatches = (candidate: MeshWorkQueueEntry): boolean => {
-                // SESSION-ID IS SINGLE-FORM: unlike node/daemon ids (3 serialization
-                // forms requiring expandDaemonIdForms), a session id is a single
-                // canonical UUID minted once via crypto.randomUUID() in the provider
-                // instance (cli/acp/extension/ide) and carried verbatim across daemons
-                // (resolveEventSessionId applies no transformation). So an exact `!==`
-                // is correct here and needs no normalization helper.
-                if (candidate.targetSessionId && candidate.targetSessionId !== sessionId) return false;
+                // Session ids are single-form (unlike node/daemon ids with their 3
+                // serialization forms requiring expandDaemonIdForms) — see the
+                // sessionIdsEquivalent doc; it is the one canonical exact-match
+                // predicate for them.
+                if (candidate.targetSessionId && !sessionIdsEquivalent(candidate.targetSessionId, sessionId)) return false;
                 if (
                     candidate.targetNodeId
                     && !daemonIdsEquivalent(candidate.targetNodeId, nodeId)

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

@@ -9,6 +9,7 @@ import { appendLedgerEntry } from './mesh-ledger.js';
 import type { MeshLedgerKind } from './mesh-ledger.js';
 import { createSessionDelivery } from './mesh-delivery-policy.js';
 import { isTaskDispatchInFlight, endTaskDispatchInFlight } from './mesh-task-inflight.js';
+import { sessionIdsEquivalent } from '@adhdev/mesh-shared';
 
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
 export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
@@ -1248,7 +1249,7 @@ export function updateSessionTaskStatus(
             // `assigned` for 19 minutes. If the session still has an assigned row we
             // failed to resolve, surface it loudly instead of dropping the completion.
             const assignedRows = store.getActiveAssignmentDetails(meshId)
-                .filter(r => r.sessionId === sessionId);
+                .filter(r => sessionIdsEquivalent(r.sessionId, sessionId));
             if (assignedRows.length > 0) {
                 LOG.warn('MeshQueue', `No assigned queue row matched completion for mesh ${meshId} session ${sessionId} `
                     + `(taskId=${opts?.taskId ?? 'none'}, occurredAt=${occurredAtIso ?? 'none'}); `