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

package/dist/mesh/mesh-events-coordinator.d.ts

@@ -2,6 +2,11 @@ import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 export declare function __resetIdleAutoFastForwardForTests(): void;
 export declare function __resetMeshWorkspaceCacheForTests(): void;
 export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+/** Active assignments that hold the one-active-per-node / global-parallel invariant
+ *  (everything except read-only diagnoses, which run unbounded by the write cap). */
+export declare function activeWriteAssignedCount(meshId: string): number;
+/** Active read-only (live_debug_readonly) assignments, for the read-only safety cap. */
+export declare function activeReadonlyAssignedCount(meshId: string): number;
 export interface MeshQueueTriggerResult {
     success: true;
     meshId: string;

package/dist/mesh/mesh-runtime-store.d.ts

@@ -30,6 +30,10 @@ export declare class MeshRuntimeStore {
     updateQueueEntry(entry: MeshWorkQueueEntry): void;
     findQueueEntryById(meshId: string, id: string): MeshWorkQueueEntry | null;
     hasActiveAssignment(meshId: string, sessionId: string, nodeId: string): boolean;
+    /** A session may only execute one task at a time, regardless of task mode. */
+    private hasActiveSessionAssignment;
+    /** A node may only execute one write task at a time (worktree isolation). */
+    private hasActiveNodeAssignment;
     claimNextQueueTask(meshId: string, nodeId: string, sessionId: string, capabilityTags?: string[]): MeshWorkQueueEntry | null;
     getQueueStatsByStatus(meshId: string): {
         status: string;

package/package.json

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

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

@@ -15,7 +15,7 @@ import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
 import { enqueueUnresolvedDelegateForward, peekUnresolvedDelegateForwards, ackUnresolvedDelegateForward } from './mesh-unresolved-forward-outbox.js';
 import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
-import { normalizeMeshNodeId, meshNodeIdMatches } from '@adhdev/mesh-shared';
+import { normalizeMeshNodeId, meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
     hasDispatchAfterTerminal,
@@ -109,7 +109,10 @@ function hasRecentIntentionalCleanupStop(meshId: string, sessionId?: string, nod
         if (!Number.isNaN(timestamp) && timestamp < cutoff) break;
         if (!isIntentionalCleanupStopEntry(entry)) continue;
         if (sessionId && entry.sessionId === sessionId) return true;
-        if (!sessionId && nodeId && entry.nodeId === nodeId) return true;
+        // Normalized node-id match (P4): the cleanup-stop entry's node id may be stored as
+        // `nodeId` or `node_id` and the `nodeId` arg can be in either form — a raw `===`
+        // would miss a genuine intentional-cleanup entry and fail to suppress the stop event.
+        if (!sessionId && nodeId && meshNodeIdMatches(entry as unknown as MeshNodeIdentified, nodeId)) return true;
     }
     return false;
 }
@@ -471,6 +474,19 @@ function activeAssignedCount(meshId: string): number {
     return getQueue(meshId, { status: ['assigned'] as any }).length;
 }
 
+/** Active assignments that hold the one-active-per-node / global-parallel invariant
+ *  (everything except read-only diagnoses, which run unbounded by the write cap). */
+export function activeWriteAssignedCount(meshId: string): number {
+    return getQueue(meshId, { status: ['assigned'] as any })
+        .filter(task => task.taskMode !== 'live_debug_readonly').length;
+}
+
+/** Active read-only (live_debug_readonly) assignments, for the read-only safety cap. */
+export function activeReadonlyAssignedCount(meshId: string): number {
+    return getQueue(meshId, { status: ['assigned'] as any })
+        .filter(task => task.taskMode === 'live_debug_readonly').length;
+}
+
 function nodeHasActiveAssignment(meshId: string, nodeId: string): boolean {
     return getQueue(meshId, { status: ['assigned'] as any }).some(task => task.assignedNodeId === nodeId);
 }
@@ -625,10 +641,22 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
     if (!pending.length) return false;
 
     const maxParallelTasks = Math.max(1, Math.floor(Number(mesh?.policy?.maxParallelTasks) || 2));
+    // Read-only diagnoses carry no isolation/merge cost, so they are exempt from the
+    // write-task parallel cap. To prevent runaway auto-launch they get their own,
+    // higher safety cap (2x the write cap).
+    const maxReadonlyParallelTasks = Math.max(2, maxParallelTasks * 2);
     for (const task of pending) {
-        if (activeAssignedCount(meshId) >= maxParallelTasks) {
+        const isReadonly = task.taskMode === 'live_debug_readonly';
+        if (isReadonly) {
+            if (activeReadonlyAssignedCount(meshId) >= maxReadonlyParallelTasks) {
+                markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'max_readonly_parallel_tasks_reached' });
+                continue;
+            }
+        } else if (activeWriteAssignedCount(meshId) >= maxParallelTasks) {
+            // Write tasks are capped; skip this one but keep scanning so a later
+            // read-only task in the queue can still launch under its own cap.
             markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'max_parallel_tasks_reached' });
-            return false;
+            continue;
         }
         if (task.targetSessionId) {
             markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'target_session_constraint' });
@@ -684,7 +712,10 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                 markAutoLaunch(meshId, task.id, { status: 'skipped', reason: localSkipReason, nodeId });
                 continue;
             }
-            if (nodeHasActiveAssignment(meshId, nodeId)) {
+            // Write tasks keep the one-active-per-node invariant (worktree isolation);
+            // read-only (live_debug_readonly) diagnoses may auto-launch onto a node
+            // that already has an active assignment.
+            if (task.taskMode !== 'live_debug_readonly' && nodeHasActiveAssignment(meshId, nodeId)) {
                 markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'node_has_active_assignment', nodeId });
                 continue;
             }

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

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

package/src/mesh/mesh-routing.ts

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

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

@@ -459,11 +459,37 @@ export class MeshRuntimeStore {
         return row !== undefined;
     }
 
+    /** A session may only execute one task at a time, regardless of task mode. */
+    private hasActiveSessionAssignment(meshId: string, sessionId: string): boolean {
+        const row = this.db.prepare(`
+            SELECT 1 FROM mesh_queue
+            WHERE mesh_id = ? AND status = 'assigned' AND assigned_session_id = ?
+            LIMIT 1
+        `).get(meshId, sessionId);
+        return row !== undefined;
+    }
+
+    /** A node may only execute one write task at a time (worktree isolation). */
+    private hasActiveNodeAssignment(meshId: string, nodeId: string): boolean {
+        const row = this.db.prepare(`
+            SELECT 1 FROM mesh_queue
+            WHERE mesh_id = ? AND status = 'assigned' AND assigned_node_id = ?
+            LIMIT 1
+        `).get(meshId, nodeId);
+        return row !== undefined;
+    }
+
     // O(1) claim: transaction ensures only one session claims a pending task
     claimNextQueueTask(meshId: string, nodeId: string, sessionId: string, capabilityTags: string[] = []): MeshWorkQueueEntry | null {
         return this.transaction(() => {
             this.ensureLegacyQueueMigrated(meshId);
-            if (this.hasActiveAssignment(meshId, sessionId, nodeId)) return null;
+            // A session executes one task at a time regardless of mode — block early.
+            // The node-level conflict is evaluated per-candidate below so that
+            // read-only (live_debug_readonly) tasks can claim concurrently on a node
+            // that already has an active assignment, while write tasks keep the
+            // one-active-per-node invariant (worktree isolation).
+            if (this.hasActiveSessionAssignment(meshId, sessionId)) return null;
+            const nodeBusy = this.hasActiveNodeAssignment(meshId, nodeId);
 
             // Priority: session-targeted > node-targeted (no session) > unconstrained
             const rows = [
@@ -508,9 +534,18 @@ export class MeshRuntimeStore {
                 return deps.every(depId => depStatus.get(depId) === 'completed');
             };
 
+            // Per-candidate node-conflict gate: write tasks (anything other than
+            // live_debug_readonly) require an idle node; read-only tasks bypass the
+            // node-busy check so N read-only diagnoses can run on one node at once.
+            const nodeConflictAllows = (candidate: MeshWorkQueueEntry): boolean => {
+                if (candidate.taskMode === 'live_debug_readonly') return true;
+                return !nodeBusy;
+            };
+
             const entry = candidates.find(candidate =>
                 nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags)
-                && dependenciesSatisfied(candidate));
+                && dependenciesSatisfied(candidate)
+                && nodeConflictAllows(candidate));
             if (!entry) return null;
 
             const now = new Date().toISOString();