@adhdev/daemon-core 0.9.82-rc.381 → 0.9.82-rc.383

package/dist/mesh/mesh-event-forwarding.d.ts

@@ -1,4 +1,5 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+export declare function recoverMeshIdByCoordinatorAndNode(coordinatorDaemonId: string, nodeId: string): string;
 export declare function resolveForwardEventMeshId(components: DaemonComponents, payload: Record<string, unknown>): string;
 export declare function __resetMeshWorkspaceCacheForTests(): void;
 export declare function buildRelayMetadataEvent(payload: Record<string, unknown>): Record<string, unknown>;

package/dist/providers/cli-provider-instance.d.ts

@@ -150,6 +150,24 @@ export declare class CliProviderInstance implements ProviderInstance {
      * terminal state. Leaving meshNodeFor pinned would route this session's
      * subsequent unrelated turns (e.g. ad-hoc dashboard chats) to the
      * coordinator as if they were task completions.
+     *
+     * MESHID-DROP-ON-DETACH (Fix C): a coordinator-LAUNCHED worker session
+     * (launchedByCoordinator) holds its mesh membership (meshNodeFor / meshNodeId /
+     * meshCoordinatorDaemonId) at the SESSION level — set once at launch
+     * (mesh_launch_session / queue auto-launch), independent of any single task.
+     * The original detach wiped meshNodeFor + meshNodeId together with the
+     * task-level meshActiveTaskId, so the FIRST task completion stripped the
+     * membership and EVERY subsequent completion forwarded with meshId absent —
+     * resolveWorkerDelegateRouting fell to mesh_unresolved and the coordinator
+     * rejected the forward "meshId required". For a launched member we therefore
+     * clear ONLY the task-level marker (meshActiveTaskId) and preserve the
+     * session-level membership so its next task's completion still resolves.
+     * A task-less ad-hoc turn on a preserved-membership session is NOT misrouted:
+     * its completion carries no taskId and the session holds no active assignment,
+     * so the forwarder's WARMUPGAP guard skips the dispatch-row flip (it only
+     * injects a benign task-less notification). A NON-launched session (a plain CLI
+     * session adopted by mesh_send_task --direct, launchedByCoordinator falsy)
+     * keeps the original full clear so an ad-hoc session is never left pinned.
      */
     detachMeshAssignment(): void;
     /**

package/package.json

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

package/src/commands/high-family/mesh-status.ts

@@ -107,6 +107,19 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                     const queue = getQueue(meshId);
                     const queueSummary = getMeshQueueStats(meshId);
 
+                    // Scheduling-runtime projection — the load-balancer's live view (tie-break
+                    // strategy, global parallel caps + consumption, per-node load/priority/provider
+                    // caps). Built from the SAME helper + args the MCP `mesh_status` tool uses
+                    // (mesh-tools-status.ts: buildMeshSchedulingRuntime(mesh, getQueue(mesh.id)))
+                    // so the dashboard surface and the coordinator MCP surface render an identical
+                    // runtime. Without this the dashboard Status/Runtime tab showed the
+                    // "not reported by this daemon (older build)" fallback (RepoMeshStatus.scheduling
+                    // was never populated by this daemon-command producer). Computed once so each
+                    // node entry can attach its slice and statusResult can carry the mesh rollup.
+                    const { buildMeshSchedulingRuntime } = await import('../../mesh/mesh-scheduling-runtime.js');
+                    const schedulingRuntime = buildMeshSchedulingRuntime(mesh, queue);
+                    const schedulingByNode = new Map(schedulingRuntime.nodes.map(n => [n.nodeId, n]));
+
                     const { readLedgerEntries, getLedgerSummary } = await import('../../mesh/mesh-ledger.js');
                     const ledgerEntries = readLedgerEntries(meshId, { tail: 20 });
                     const asyncRefineLedgerEntries = readLedgerEntries(meshId, { tail: 100 });
@@ -260,6 +273,16 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                             activeSessionDetails: [],
                             launchReady: false,
                         };
+                        // Per-node scheduling slice (load / priority / provider caps / claim-block
+                        // reasons) read by the dashboard's MeshNodeSchedulingBadges. Full shape —
+                        // unlike the MCP compact path this is a dashboard surface, so it keeps the
+                        // whole RepoMeshNodeSchedulingStatus. Redundant nodeId dropped (the entry
+                        // already carries it).
+                        const nodeScheduling = schedulingByNode.get(nodeId);
+                        if (nodeScheduling) {
+                            const { nodeId: _omitNodeId, ...nodeSchedulingRest } = nodeScheduling;
+                            status.scheduling = nodeSchedulingRest;
+                        }
                         if (isSelfNode) {
                             status.connection = {
                                 perspective: 'selected_coordinator',
@@ -511,6 +534,19 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         branchConvergenceSummary: summarizeInlineMeshBranchConvergence(nodeStatuses),
                         ...(previewFreshness ? { previewFreshness, deployFreshness: previewFreshness } : {}),
                         nodes: nodeStatuses,
+                        // Mesh-level scheduling rollup (strategy + global cap consumption). Mirrors
+                        // the MCP `mesh_status` tool's `scheduling` block field-for-field so both
+                        // surfaces read the same runtime; per-node detail lives on each
+                        // nodes[].scheduling above.
+                        scheduling: {
+                            strategy: schedulingRuntime.strategy,
+                            maxParallelTasks: schedulingRuntime.maxParallelTasks,
+                            maxReadonlyParallelTasks: schedulingRuntime.maxReadonlyParallelTasks,
+                            activeWriteAssigned: schedulingRuntime.activeWriteAssigned,
+                            activeReadonlyAssigned: schedulingRuntime.activeReadonlyAssigned,
+                            globalWriteCapReached: schedulingRuntime.globalWriteCapReached,
+                            globalReadonlyCapReached: schedulingRuntime.globalReadonlyCapReached,
+                        },
                         queue: { tasks: queue, summary: queueSummary },
                         ledger: { entries: ledgerEntries, summary: ledgerSummary },
                         ...(missions.length > 0 ? { missions } : {}),

package/src/commands/router.ts

@@ -491,25 +491,51 @@ export class DaemonCommandRouter {
      * the wider plural-shape scan so a controlbar/modal command targeting a non-primary remote
      * session still resolves its owner — the singular readCachedInlineMeshActiveSessions semantics
      * other consumers depend on stay untouched.
+     *
+     * CANCEL-STOP-RELAY: the session-id cache scan above only matches when the coordinator's
+     * cached status snapshot already lists the worker's session id in a recognized active-sessions
+     * shape. A worktree-clone worker session whose id form/timing differs from the cached snapshot
+     * (or is simply not yet reflected) misses the scan, so a stop that carries the authoritative
+     * owning nodeId (mesh_queue_cancel knows assignedNodeId) used to silently fail to forward.
+     * `ownerNodeIdHint` adds a deterministic fallback: when the session-id scan misses, resolve the
+     * owner daemonId by matching the node by id (meshNodeIdMatches — same form-tolerant compare the
+     * rest of the router uses, no new raw compare). The same self-loopback guard applies to both
+     * paths, so a coordinator-hosted node is still never force-forwarded to a remote form of itself.
      */
-    public resolveRemoteMeshSessionOwnerDaemonId(sessionId: string): string | undefined {
+    public resolveRemoteMeshSessionOwnerDaemonId(sessionId: string, ownerNodeIdHint?: string): string | undefined {
         const trimmed = typeof sessionId === 'string' ? sessionId.trim() : '';
-        if (!trimmed) return undefined;
+        const nodeHint = typeof ownerNodeIdHint === 'string' ? ownerNodeIdHint.trim() : '';
+        if (!trimmed && !nodeHint) return undefined;
         const selfDaemonId = this.deps.statusInstanceId;
-        for (const node of this.collectMeshSessionOwnerCandidateNodes()) {
-            if (!collectMeshNodeHostedSessionIds(node).has(trimmed)) continue;
-            const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
-            // A matching node with no readable daemonId can't be attributed — keep scanning
-            // the remaining candidates (e.g. the same session on an aggregate node that does
-            // carry the daemonId) rather than bailing on the whole resolution.
-            if (!nodeDaemonId) continue;
-            // Only forward to a genuinely remote daemon. When the owning node is this
-            // coordinator itself (locally hosted worker), fall through to local handling.
-            // id-form robust: the node daemonId and selfDaemonId may be stored in different
-            // forms of the same machine — a strict `===` would miss the self-match and forward
-            // a local session to a remote form of THIS daemon (loopback).
-            if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return undefined;
-            return nodeDaemonId;
+        const candidates = this.collectMeshSessionOwnerCandidateNodes();
+        if (trimmed) {
+            for (const node of candidates) {
+                if (!collectMeshNodeHostedSessionIds(node).has(trimmed)) continue;
+                const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
+                // A matching node with no readable daemonId can't be attributed — keep scanning
+                // the remaining candidates (e.g. the same session on an aggregate node that does
+                // carry the daemonId) rather than bailing on the whole resolution.
+                if (!nodeDaemonId) continue;
+                // Only forward to a genuinely remote daemon. When the owning node is this
+                // coordinator itself (locally hosted worker), fall through to local handling.
+                // id-form robust: the node daemonId and selfDaemonId may be stored in different
+                // forms of the same machine — a strict `===` would miss the self-match and forward
+                // a local session to a remote form of THIS daemon (loopback).
+                if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return undefined;
+                return nodeDaemonId;
+            }
+        }
+        // Deterministic fallback: the session-id scan missed (cache lag / id-form mismatch on a
+        // worktree-clone worker), but the caller knows the authoritative owning nodeId. Resolve the
+        // owner daemonId straight off that node — never the fuzzy session cache.
+        if (nodeHint) {
+            for (const node of candidates) {
+                if (!meshNodeIdMatches(node, nodeHint)) continue;
+                const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
+                if (!nodeDaemonId) continue;
+                if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return undefined;
+                return nodeDaemonId;
+            }
         }
         return undefined;
     }
@@ -3092,7 +3118,14 @@ export class DaemonCommandRouter {
                 const localInstance = this.deps.instanceManager?.getInstance(targetSessionId);
                 const localRegistry = this.deps.sessionRegistry?.get?.(targetSessionId);
                 if (!localInstance && !localRegistry) {
-                    const ownerDaemonId = this.resolveRemoteMeshSessionOwnerDaemonId(targetSessionId);
+                    // CANCEL-STOP-RELAY: pass the authoritative owning nodeId (when the caller
+                    // shipped one in meshContext, e.g. mesh_queue_cancel's assignedNodeId) as the
+                    // deterministic owner-resolution fallback. The session-id cache scan stays the
+                    // primary path; the hint only kicks in when that scan misses (worktree-clone
+                    // worker session not yet in / form-mismatched against the cached snapshot).
+                    const meshContext = readObjectRecord(args?.meshContext);
+                    const ownerNodeIdHint = readStringValue(meshContext.nodeId);
+                    const ownerDaemonId = this.resolveRemoteMeshSessionOwnerDaemonId(targetSessionId, ownerNodeIdHint);
                     if (ownerDaemonId) {
                         LOG.info('Mesh', `[Mesh] Forwarding session-scoped '${cmd}' for remote worker session ${targetSessionId.split('_')[0]} → daemon ${ownerDaemonId.slice(0, 12)}`);
                         const forwarded = await this.deps.dispatchMeshCommand(ownerDaemonId, cmd, {

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

@@ -9,6 +9,7 @@ import { markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompl
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents } from './mesh-events-pending.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
+import { resolveMeshHostStatus } from './mesh-host-ownership.js';
 import { enqueueUnresolvedDelegateForward, peekUnresolvedDelegateForwards, ackUnresolvedDelegateForward } from './mesh-unresolved-forward-outbox.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { getLastDisplayMessage } from '../status/snapshot.js';
@@ -92,6 +93,38 @@ function recoverMeshIdByNodeId(nodeId: string): string {
     return '';
 }
 
+// MESHID-DROP coordinator-anchor recovery (Fix B): the last-resort meshId recovery for an
+// unresolved-delegate forward whose payload carries the worker's coordinator anchor
+// (meshCoordinatorDaemonId) but no resolvable meshId — neither workspace nor nodeId scan
+// matched (a freshly-cloned worktree node not yet registered under the forwarded id form, or
+// an empty payload nodeId). The receiving daemon IS the coordinator/host, so scope to the
+// meshes IT hosts whose host daemon matches the anchor (daemonIdsEquivalent — never a raw
+// compare, so daemon_mach_/mach_/standalone_ forms all match the same machine). Among those:
+//   • a nodeId → the mesh whose nodes contain it (meshNodeIdMatches 3-form) wins;
+//   • no nodeId → fall back to the anchor's SINGLE hosted mesh only. Ambiguity (the anchor
+//     hosts >1 mesh and no node disambiguates) returns '' rather than guess — a wrong meshId
+//     would inject the completion into an unrelated mesh's ledger, worse than the retry-cap drop.
+export function recoverMeshIdByCoordinatorAndNode(coordinatorDaemonId: string, nodeId: string): string {
+    if (!coordinatorDaemonId) return '';
+    const hosted = listMeshes().filter(mesh => {
+        const host = resolveMeshHostStatus(mesh);
+        return host.role === 'host'
+            && (!host.hostDaemonId || daemonIdsEquivalent(host.hostDaemonId, coordinatorDaemonId));
+    });
+    if (hosted.length === 0) return '';
+    if (nodeId) {
+        const byNode = hosted.find(mesh =>
+            Array.isArray(mesh.nodes) && mesh.nodes.some((n: any) => meshNodeIdMatches(n, nodeId)));
+        if (byNode) return readNonEmptyString(byNode.id);
+        // nodeId present but matched no hosted mesh — do NOT fall through to the single-mesh
+        // guess; the node belongs to a mesh we don't host (or under a different id), and
+        // guessing would misroute. Stay unresolved.
+        return '';
+    }
+    // No nodeId to disambiguate: only safe when the anchor hosts exactly one mesh.
+    return hosted.length === 1 ? readNonEmptyString(hosted[0].id) : '';
+}
+
 // RECONCILE-MESHID-DROP: WORKER-side meshId resolution for an unresolved-delegate
 // forward payload. forwardUnresolvedDelegateEvent omits meshId by design (the worker
 // "can't resolve it") and relies on the COORDINATOR recovering it from workspace/nodeId.
@@ -1234,7 +1267,14 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
     // The nodeId is a stable coordinator-side fact and resolves timing-independently.
     const meshId = readNonEmptyString(payload.meshId)
         || (workspace ? readNonEmptyString(getCachedMeshByWorkspace(workspace)?.id) : '')
-        || recoverMeshIdByNodeId(nodeId);
+        || recoverMeshIdByNodeId(nodeId)
+        // Fix B last resort: workspace + nodeId scan both missed, but the worker stamped
+        // its coordinator anchor onto the forward (forwardUnresolvedDelegateEvent). Recover
+        // via the hosted mesh that anchor owns (+ node disambiguation), guarding ambiguity.
+        || recoverMeshIdByCoordinatorAndNode(
+            readNonEmptyString(payload.meshCoordinatorDaemonId) || readNonEmptyString(payload.coordinatorDaemonId),
+            nodeId,
+        );
     if (!meshId) {
         // EVTTRACE: forwarded event rejected at receive — no meshId could be resolved
         // (no payload.meshId, no workspace→mesh, no nodeId→mesh). Observation only.
@@ -1364,6 +1404,11 @@ function forwardUnresolvedDelegateEvent(
         event: eventName,
         nodeId: readNonEmptyString(routing.nodeId) || readNonEmptyString(event.meshNodeId) || undefined,
         workspace: readNonEmptyString(routing.workspace) || readNonEmptyString(event.workspace) || undefined,
+        // Fix B: carry the resolved coordinator anchor so the coordinator's receive-side
+        // recovery (recoverMeshIdByCoordinatorAndNode) can match this forward to one of the
+        // meshes it hosts when workspace + nodeId both miss. routing.coordinatorDaemonId is
+        // the same anchor this forward is addressed to (coordinatorDaemonId below).
+        meshCoordinatorDaemonId: coordinatorDaemonId,
     };
     // RECONCILE-MESHID-DROP: stamp meshId when the WORKER can resolve it (member node /
     // live-session meshNodeFor). Historically omitted "because the worker can't resolve

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

@@ -49,7 +49,7 @@ import { drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, bui
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { appendLedgerEntry } from './mesh-ledger.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { handleMeshForwardEvent, shouldForceInjectMeshEvent, MESH_FORCE_INJECT_EVENTS, triggerMeshQueue, resolveForwardEventMeshId } from './mesh-events-coordinator.js';
+import { handleMeshForwardEvent, shouldForceInjectMeshEvent, triggerMeshQueue, resolveForwardEventMeshId } from './mesh-events-coordinator.js';
 import {
     peekUnresolvedDelegateForwards,
     ackUnresolvedDelegateForward,
@@ -589,35 +589,53 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
     for (const [meshId, meshCoordinators] of byMesh) {
         // Drain the local queue scoped to this coordinator daemon and inject.
         //     - If an idle coordinator exists, FULL-drain and deliver every event to it
-        //       (it can receive non-force progress events without deadlocking).
-        //     - If only GENERATING coordinators exist, force-drain ONLY the force-inject
-        //       events (completion/approval/stop/refine·bootstrap terminal) and force-inject
-        //       them so a coordinator parked in `generating` while awaiting that very event
-        //       is not deadlocked. Non-force progress events stay queued for the next idle
-        //       tick — injecting them would be noise mid-generation. Both drains mark the
-        //       consumed rows drained=1 atomically, so the pull path can't re-deliver.
+        //       (the idle input box accepts the prompt as a real next turn). The drain
+        //       marks consumed rows drained=1 atomically, so the pull path can't re-deliver.
+        //     - If only GENERATING coordinators exist (no idle target), we HOLD: leave the
+        //       events queued (drained=0) for the coordinator's next idle/turn-end tick.
+        //
+        // NOTIF-SURFACE-LOCAL (false-idle hold): we used to force-inject terminal events
+        // (completion/approval/stop/refine·bootstrap) straight into a *generating*
+        // coordinator's PTY (forceSendMessage → atomic content+\r write), on the theory it
+        // bypassed the busy send-guard and broke the await-result deadlock. But a raw PTY
+        // write into a claude-cli that is mid-generation is NOT consumed as a new turn — the
+        // bytes land in the terminal input buffer and the LLM never reads them on its next
+        // turn. The `surfaced/force-inject` trace fired, the row was marked drained=1, and the
+        // genuine completion was lost forever (the exact same-daemon local-worktree miss: the
+        // coordinator's OWN session is generating at the moment its worker completes). The
+        // deadlock the force path guarded against does not actually require force: a
+        // coordinator that dispatched a task via mesh_send_task returns to idle when that
+        // tool call resolves (dispatch is fire-and-forget; the worker runs for minutes while
+        // the coordinator is idle/between turns), so the completion lands on the very next
+        // idle tick (≤ one reconcile interval). Holding the event undrained for that idle
+        // tick is therefore the single, reliable delivery — and it is the SAME skip-and-hold
+        // the modal-park branch below already uses. This also makes double-injection
+        // structurally impossible: there is exactly one delivery path (the idle full-drain),
+        // so we never need a surface-time fingerprint to dedup a force-write against a re-drain.
         const idleCoordinators = meshCoordinators.filter(c => c.idle);
-        // A coordinator parked on a harness modal (waiting_choice / waiting_approval)
-        // is non-idle, so it would otherwise be treated as a force-inject target. It
-        // must NOT be: a force-inject writes raw keystrokes into the PTY, which the
-        // modal's key handler consumes and silently resolves to a choice the user
-        // never made. Force-inject is only safe into a coordinator parked in plain
-        // `generating` (the deadlock the force path exists to break). So generating
-        // targets are the non-idle, non-modal-parked coordinators.
+        // A coordinator parked on a harness modal (waiting_choice / waiting_approval) is
+        // non-idle; it is held under the modal-park branch (a force-inject into a modal would
+        // write raw keystrokes the modal key handler eats, silently selecting a choice the
+        // user never made). A plainly-generating coordinator (non-idle, non-modal-parked) is
+        // ALSO held now — for the false-idle reason above — but separately, so the C1 ledger
+        // audit and the operator-facing skip log can name the right hold reason.
         const generatingCoordinators = meshCoordinators.filter(c => !c.idle && !c.modalParked);
         const modalParkedCoordinators = meshCoordinators.filter(c => !c.idle && c.modalParked);
-        const targetCoordinators = idleCoordinators.length > 0 ? idleCoordinators : generatingCoordinators;
-        const forceOnly = idleCoordinators.length === 0;
-
-        // ── modal-blocked short-circuit (MUST precede the drain) ──────────────────
-        // When the ONLY coordinators for this mesh are modal-parked (no idle, no plain
-        // generating target), there is nowhere safe to deliver. We skip-and-requeue:
-        // by NOT draining we leave the events at drained=0 in the queue, so a later tick
-        // (once the modal is resolved and the coordinator returns to idle/generating)
-        // delivers them. This short-circuit MUST run BEFORE drainPendingMeshCoordinatorEvents
-        // — the drain marks rows drained=1 atomically, which would lose the events for a
-        // coordinator that is only transiently blocked. (Note: generating is still
-        // force-injected via generatingCoordinators — we never block the deadlock-break.)
+        // Only an IDLE coordinator is a deliverable target. A generating coordinator's PTY
+        // does not consume an injected prompt as a turn, so it is held (not a target).
+        const targetCoordinators = idleCoordinators;
+
+        // ── no-idle-target short-circuit (MUST precede the drain) ─────────────────
+        // When there is no IDLE coordinator for this mesh — only generating and/or
+        // modal-parked ones — there is nowhere a queued event can land as a real turn.
+        // We skip-and-hold: by NOT draining we leave the events at drained=0 in the queue,
+        // so a later tick (once a coordinator returns to idle) delivers them. This
+        // short-circuit MUST run BEFORE drainPendingMeshCoordinatorEvents — the drain marks
+        // rows drained=1 atomically, which would lose the events for a coordinator that is
+        // only transiently busy (the false-idle local-worktree miss). Both the generating
+        // hold and the modal-park hold record a C1 ledger audit copy so a held completion's
+        // worker summary is recoverable even if the coordinator never returns or the pending
+        // file is later trimmed.
         if (targetCoordinators.length === 0) {
             if (modalParkedCoordinators.length > 0) {
                 // ── orphan escape (MUST precede the blanket modal-park hold) ──────────
@@ -705,6 +723,30 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
                         modalParkedCoordinators.length,
                     );
                 }
+            } else if (generatingCoordinators.length > 0) {
+                // ── generating hold (NOTIF-SURFACE-LOCAL false-idle fix) ─────────────
+                // The only coordinator(s) for this mesh are plainly generating (no idle, no
+                // modal). A raw force-write into a generating claude-cli PTY is not consumed
+                // as a turn, so we do NOT inject and do NOT drain — the events stay queued
+                // (drained=0) and the next tick that finds the coordinator idle full-drains
+                // them as real turns (the coordinator returns to idle when its current
+                // tool-call/turn resolves; a dispatched worker runs for minutes while the
+                // coordinator is idle, so this lands within one reconcile interval). C1: mirror
+                // any held terminal events into the ledger so a completion's worker summary is
+                // recoverable even before that idle tick. Idempotent per process; O(1)-gated.
+                let hasPending = true;
+                if (store) {
+                    try { hasPending = store.pendingEventCount(meshId) > 0; } catch { /* peek below */ }
+                }
+                if (hasPending) {
+                    LOG.info('MeshReconcile', `Reconcile skip → generating: holding pending event(s) for mesh ${meshId} (${generatingCoordinators.length} coordinator(s) busy; events left queued for the next idle tick)`);
+                    recordHeldTerminalEventsToLedger(
+                        meshId,
+                        drainDaemonIds.length > 0 ? drainDaemonIds : (localDaemonId ? [localDaemonId] : []),
+                        'generating_no_idle_coordinator',
+                        generatingCoordinators.length,
+                    );
+                }
             }
             continue;
         }
@@ -716,12 +758,15 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
             } catch { /* fall through to drain */ }
         }
 
+        // An idle coordinator is present (targetCoordinators.length > 0): FULL-drain every
+        // queued event and deliver it to the idle input box as a real turn. The no-idle case
+        // (generating/modal-only) was already held above and never reaches here, so there is
+        // no force-drain-into-generating path left — the single delivery is the idle drain.
         let pendingEvents: PendingMeshCoordinatorEvent[] = [];
         try {
             pendingEvents = drainPendingMeshCoordinatorEvents(
                 meshId,
                 drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
-                forceOnly ? { onlyEvents: MESH_FORCE_INJECT_EVENTS } : undefined,
             );
         } catch (e: any) {
             LOG.warn('MeshReconcile', `Drain failed for mesh ${meshId}: ${e?.message || e}`);
@@ -729,8 +774,7 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         }
         if (pendingEvents.length === 0) continue;
 
-        const mode = forceOnly ? 'force-drain → generating' : 'inject → idle';
-        LOG.info('MeshReconcile', `Reconcile ${mode}: ${pendingEvents.length} pending event(s) → ${targetCoordinators.length} coordinator(s) for mesh ${meshId}`);
+        LOG.info('MeshReconcile', `Reconcile inject → idle: ${pendingEvents.length} pending event(s) → ${targetCoordinators.length} coordinator(s) for mesh ${meshId}`);
         for (const pending of pendingEvents) {
             // Strict session routing (multi-coordinator): when the event names an
             // originating coordinator session, deliver ONLY to the live coordinator whose

package/src/providers/cli-provider-instance.ts

@@ -972,9 +972,36 @@ export class CliProviderInstance implements ProviderInstance {
      * terminal state. Leaving meshNodeFor pinned would route this session's
      * subsequent unrelated turns (e.g. ad-hoc dashboard chats) to the
      * coordinator as if they were task completions.
+     *
+     * MESHID-DROP-ON-DETACH (Fix C): a coordinator-LAUNCHED worker session
+     * (launchedByCoordinator) holds its mesh membership (meshNodeFor / meshNodeId /
+     * meshCoordinatorDaemonId) at the SESSION level — set once at launch
+     * (mesh_launch_session / queue auto-launch), independent of any single task.
+     * The original detach wiped meshNodeFor + meshNodeId together with the
+     * task-level meshActiveTaskId, so the FIRST task completion stripped the
+     * membership and EVERY subsequent completion forwarded with meshId absent —
+     * resolveWorkerDelegateRouting fell to mesh_unresolved and the coordinator
+     * rejected the forward "meshId required". For a launched member we therefore
+     * clear ONLY the task-level marker (meshActiveTaskId) and preserve the
+     * session-level membership so its next task's completion still resolves.
+     * A task-less ad-hoc turn on a preserved-membership session is NOT misrouted:
+     * its completion carries no taskId and the session holds no active assignment,
+     * so the forwarder's WARMUPGAP guard skips the dispatch-row flip (it only
+     * injects a benign task-less notification). A NON-launched session (a plain CLI
+     * session adopted by mesh_send_task --direct, launchedByCoordinator falsy)
+     * keeps the original full clear so an ad-hoc session is never left pinned.
      */
     detachMeshAssignment(): void {
         if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
+        // Session-level member: keep membership, drop only the task-level marker.
+        if (this.settings.launchedByCoordinator === true) {
+            if (!this.settings.meshActiveTaskId) return;
+            const { meshActiveTaskId, ...rest } = this.settings;
+            void meshActiveTaskId;
+            this.settings = rest;
+            this.adapter.updateRuntimeSettings?.(this.settings);
+            return;
+        }
         const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
         void meshNodeFor; void meshActiveTaskId;
         // WTCLAIM (A): clear the active binding but PRESERVE the last bound node id