@adhdev/daemon-core 0.9.82-rc.452 → 0.9.82-rc.454

package/dist/mesh/mesh-work-queue.d.ts

@@ -324,10 +324,28 @@ export declare function updateSessionTaskStatus(meshId: string, sessionId: strin
  * Used by the completion event path to decide whether to wake the queue.
  */
 export declare function hasPendingDependents(meshId: string, taskId: string): boolean;
+/**
+ * M1: THE single dependency-gate predicate. A task is claimable from a
+ * dependency standpoint iff it carries no system block (`blockedReason`) AND
+ * every id in `dependsOn` has reached 'completed'.
+ *
+ * DEPENDSON-GATE-SYMMETRY: every scheduler surface that decides whether a
+ * pending task may run MUST route through this one predicate — the queue claim
+ * (claimNextQueueTask), the auto-launch candidate filter
+ * (maybeAutoLaunchOneQueueSession), and the cloud eager P2P push
+ * (enqueue-and-push). If any surface computes dependency readiness on its own,
+ * the gate goes asymmetric and a task blocked from the pull path can still be
+ * eager-pushed straight to an idle session, silently bypassing its
+ * prerequisites. The semantics here (all deps completed && !blocked) are the
+ * invariant — do not fork them.
+ */
+export declare function taskDependenciesSatisfied(entry: Pick<MeshWorkQueueEntry, 'dependsOn' | 'blockedReason'>, statusById: Map<string, MeshTaskStatus | string>): boolean;
 /**
  * M1-4: view-time dependency state for a task — unmet dependency ids and
  * whether the task is currently claimable from a dependency standpoint.
- * Not stored (truth stays in task statuses).
+ * Not stored (truth stays in task statuses). The `dependenciesSatisfied` field
+ * is derived from {@link taskDependenciesSatisfied} so the view and the
+ * scheduler gates can never disagree.
  */
 export declare function describeTaskDependencyState(entry: Pick<MeshWorkQueueEntry, 'dependsOn' | 'blockedReason'>, statusById: Map<string, MeshTaskStatus | string>): {
     waitingOn: string[];

package/package.json

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

package/src/index.ts

@@ -270,7 +270,7 @@ export { buildMeshLedgerReconciliationEvidence, buildMeshLedgerReplicaEvidence }
 export type { AnyLedgerSlice, MeshLedgerReconciliationEvidence, MeshLedgerReplicaEvidence, MeshLedgerReplicaStatus } from './mesh/mesh-ledger-reconciliation.js';
 
 // ── Mesh Work Queue (GUPP) ──
-export { enqueueTask, recordDirectDispatchTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest, isTaskReadonly, buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, normalizeMeshCapabilityTags, resolveConvergeRequiredTags, insertDirectDispatch, getActiveDirectDispatches, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, markStaleDirectDispatches, deleteDirectDispatchesByTaskId, recordMeshToolCall, assertNoDependencyCycle, hasPendingDependents, describeTaskDependencyState } from './mesh/mesh-work-queue.js';
+export { enqueueTask, recordDirectDispatchTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest, isTaskReadonly, buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, normalizeMeshCapabilityTags, resolveConvergeRequiredTags, insertDirectDispatch, getActiveDirectDispatches, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, markStaleDirectDispatches, deleteDirectDispatchesByTaskId, recordMeshToolCall, assertNoDependencyCycle, hasPendingDependents, describeTaskDependencyState, taskDependenciesSatisfied } from './mesh/mesh-work-queue.js';
 export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshWorkQueueStats, MeshQueueMutationOptions, MeshTaskModeValidationResult, DirectDispatchRecord, MeshToolCallRateResult } from './mesh/mesh-work-queue.js';
 export { buildCompactStaleDirectWorkSummary, buildMeshActiveWork, buildMeshActiveWorkSummary, classifyStaleDirectForPrune, pruneStaleDirectDispatches, PRUNABLE_ORPHAN_STALE_REASONS } from './mesh/mesh-active-work.js';
 export type { StaleDirectPruneClassification, StaleDirectPruneResult, PruneStaleDirectDispatchesOptions } from './mesh/mesh-active-work.js';

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

@@ -6,7 +6,7 @@ import { getMesh } from '../config/mesh-config.js';
 import { detectCLI } from '../detection/cli-detector.js';
 import { LOG } from '../logging/logger.js';
 import { appendLedgerEntry } from './mesh-ledger.js';
-import { buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, claimNextTask, updateTaskStatus, getQueue, recordTaskAutoLaunch, getActiveDirectDispatches, isTaskReadonly } from './mesh-work-queue.js';
+import { buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, claimNextTask, updateTaskStatus, getQueue, recordTaskAutoLaunch, getActiveDirectDispatches, isTaskReadonly, taskDependenciesSatisfied } from './mesh-work-queue.js';
 import type { MeshWorkQueueEntry } from './mesh-work-queue.js';
 import { fastForwardMeshNode } from './mesh-fast-forward.js';
 import { createSessionDelivery, updateSessionDeliveryStatus } from './mesh-delivery-policy.js';
@@ -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;
@@ -1287,6 +1287,10 @@ function readMeshNodeId(node: any): string {
 
 async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, meshId: string, mesh: any): Promise<boolean> {
     const queue = getQueue(meshId);
+    // DEPENDSON-GATE-SYMMETRY: status index over the FULL queue (incl. completed)
+    // so the dependency gate below sees the terminal state of every referenced
+    // dependency, not just the still-active rows.
+    const statusById = new Map(queue.map(task => [task.id, task.status] as const));
     const pending = queue.filter(task => task.status === 'pending');
     if (!pending.length) return false;
 
@@ -1300,6 +1304,16 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
     // higher safety cap (default 2× the write cap).
     const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks);
     for (const task of pending) {
+        // DEPENDSON-GATE-SYMMETRY: never spawn a session for a task whose
+        // dependsOn set is not all-completed (or that carries a system block). The
+        // launched session would idle→claim and be refused by the SAME predicate in
+        // claimNextQueueTask, producing orphan-session / re-launch churn. Skip it so
+        // a later tick — after the dependency completes — launches it. Tasks with no
+        // dependsOn pass through unchanged (predicate is true).
+        if (!taskDependenciesSatisfied(task, statusById)) {
+            markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'dependencies_unsatisfied' });
+            continue;
+        }
         const isReadonly = isTaskReadonly(task);
         if (isReadonly) {
             if (activeReadonlyAssignedCount(meshId) >= maxReadonlyParallelTasks) {

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

@@ -3,8 +3,8 @@ import { dirname, join } from 'path';
 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 { nodeSatisfiesRequiredTags, isTaskReadonly, taskDependenciesSatisfied } from './mesh-work-queue.js';
+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';
@@ -756,11 +756,11 @@ export class MeshRuntimeStore {
                 ).all(meshId, ...depIds) as Array<{ id: string; status: string }>;
                 for (const r of depRows) depStatus.set(r.id, r.status);
             }
-            const dependenciesSatisfied = (candidate: MeshWorkQueueEntry): boolean => {
-                if (candidate.blockedReason) return false;
-                const deps = Array.isArray(candidate.dependsOn) ? candidate.dependsOn : [];
-                return deps.every(depId => depStatus.get(depId) === 'completed');
-            };
+            // DEPENDSON-GATE-SYMMETRY: the claim gate shares the single
+            // taskDependenciesSatisfied predicate with the auto-launch filter and
+            // the cloud eager P2P push, so a task blocked here is blocked there too.
+            const dependenciesSatisfied = (candidate: MeshWorkQueueEntry): boolean =>
+                taskDependenciesSatisfied(candidate, depStatus);
 
             // Per-candidate node-conflict gate: write tasks require an idle node; read-only
             // tasks bypass the node-busy check so N read-only diagnoses can run on one node
@@ -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'}); `
@@ -1275,10 +1276,36 @@ export function hasPendingDependents(meshId: string, taskId: string): boolean {
         .some(entry => Array.isArray(entry.dependsOn) && entry.dependsOn.includes(taskId));
 }
 
+/**
+ * M1: THE single dependency-gate predicate. A task is claimable from a
+ * dependency standpoint iff it carries no system block (`blockedReason`) AND
+ * every id in `dependsOn` has reached 'completed'.
+ *
+ * DEPENDSON-GATE-SYMMETRY: every scheduler surface that decides whether a
+ * pending task may run MUST route through this one predicate — the queue claim
+ * (claimNextQueueTask), the auto-launch candidate filter
+ * (maybeAutoLaunchOneQueueSession), and the cloud eager P2P push
+ * (enqueue-and-push). If any surface computes dependency readiness on its own,
+ * the gate goes asymmetric and a task blocked from the pull path can still be
+ * eager-pushed straight to an idle session, silently bypassing its
+ * prerequisites. The semantics here (all deps completed && !blocked) are the
+ * invariant — do not fork them.
+ */
+export function taskDependenciesSatisfied(
+    entry: Pick<MeshWorkQueueEntry, 'dependsOn' | 'blockedReason'>,
+    statusById: Map<string, MeshTaskStatus | string>,
+): boolean {
+    if (entry.blockedReason) return false;
+    const deps = Array.isArray(entry.dependsOn) ? entry.dependsOn : [];
+    return deps.every(depId => statusById.get(depId) === 'completed');
+}
+
 /**
  * M1-4: view-time dependency state for a task — unmet dependency ids and
  * whether the task is currently claimable from a dependency standpoint.
- * Not stored (truth stays in task statuses).
+ * Not stored (truth stays in task statuses). The `dependenciesSatisfied` field
+ * is derived from {@link taskDependenciesSatisfied} so the view and the
+ * scheduler gates can never disagree.
  */
 export function describeTaskDependencyState(
     entry: Pick<MeshWorkQueueEntry, 'dependsOn' | 'blockedReason'>,
@@ -1288,7 +1315,7 @@ export function describeTaskDependencyState(
     const waitingOn = deps.filter(depId => statusById.get(depId) !== 'completed');
     return {
         waitingOn,
-        dependenciesSatisfied: waitingOn.length === 0 && !entry.blockedReason,
+        dependenciesSatisfied: taskDependenciesSatisfied(entry, statusById),
     };
 }