@adhdev/daemon-core 0.9.82-rc.298 → 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.298",
+  "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.298",
+    "@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

@@ -474,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);
 }
@@ -628,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' });
@@ -687,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-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();