@adhdev/daemon-core 0.9.82-rc.365 → 0.9.82-rc.367

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

@@ -19,7 +19,7 @@ import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { getLastDisplayMessage } from '../status/snapshot.js';
 import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy } from '../repo-mesh-types.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
-import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, type MeshNodeIdentified } from '@adhdev/mesh-shared';
+import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, normalizeMeshWorkspaceForCompare, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
     hasDispatchAfterTerminal,
@@ -457,16 +457,10 @@ function deliverTaskToSession(dispatchThunk: () => Promise<unknown>, ctx: Delive
     });
 }
 
-// WTCLAIM: normalize a workspace path for base-vs-worktree comparison. Mirrors
-// cli-manager.ts normalizeDirForCompare (fix-B) — folds separator style, trailing
-// slashes, and case (Windows paths are case-insensitive) so a base node and a worktree
-// clone, whose only structural difference is their distinct workspace roots, are still
-// told apart. Kept local (the cli-manager copy is module-private) so the comparison rule
-// stays identical to the one fix-B already uses on the worker side.
-function normalizeMeshWorkspaceForCompare(dir?: string): string {
-    if (typeof dir !== 'string') return '';
-    return dir.trim().replace(/[\\/]+/g, '/').replace(/\/+$/, '').toLowerCase();
-}
+// WTCLAIM: workspace normalization for base-vs-worktree comparison now lives in
+// @adhdev/mesh-shared (normalizeMeshWorkspaceForCompare) so the enqueue→claim path,
+// the mesh_status per-node session filter, and the read_chat node scope guard all
+// share one comparison rule instead of drifting module-private copies.
 
 export function tryAssignQueueTask(
     components: DaemonComponents,
@@ -1325,6 +1319,14 @@ export interface MeshQueueTriggerResult {
         status?: string;
     }>;
     autoLaunchStarted: boolean;
+    /**
+     * True when a worker session is already on its way to claim a still-pending task —
+     * either launched this tick (autoLaunchStarted) or launched on a prior tick and still
+     * booting/awaiting-claim. Callers MUST treat this as "wait, do not launch another
+     * session": a second launch double-edits the worktree. Mutually informative with
+     * `noIdleMeshSessionAvailable`, which is suppressed whenever this is true.
+     */
+    autoLaunchPending?: boolean;
     noIdleMeshSessionAvailable?: boolean;
 }
 
@@ -1485,6 +1487,28 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
             nodeId: task.assignedNodeId,
             sessionId: task.assignedSessionId,
         }));
+
+    // An auto-launch is "pending" when the coordinator has already spun a session up
+    // for a still-pending task and is waiting on that session's idle→claim. This covers
+    // two ticks:
+    //   - THIS tick fired the launch (autoLaunchStarted), or
+    //   - a PRIOR tick launched a session that is still booting/awaiting-claim — the
+    //     per-task await-claim guard (maybeAutoLaunchOneQueueSession) deliberately
+    //     declines to launch again, so autoLaunchStarted is false even though a session
+    //     is on its way to claim this task.
+    // Without this signal, the second tick reports `noIdleMeshSessionAvailable` and the
+    // MCP guidance tells the coordinator to launch ANOTHER worker — producing a duplicate
+    // session that double-edits the worktree. The claim itself is fine; only the wording
+    // was wrong, so we surface `autoLaunchPending` to suppress the bad "launch one more"
+    // advice while the just-launched session converges.
+    const autoLaunchPending = autoLaunchStarted || afterQueue.some(task => {
+        if (task.status !== 'pending') return false;
+        const al = task.autoLaunch;
+        if (!al || (al.status !== 'started' && al.status !== 'completed')) return false;
+        const launchedAtMs = Date.parse(al.updatedAt);
+        return Number.isFinite(launchedAtMs) && Date.now() - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+    });
+
     return {
         success: true,
         meshId,
@@ -1498,7 +1522,11 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
         remoteIdleSessionsChecked,
         skippedSessions,
         autoLaunchStarted,
-        ...(pendingAfter > 0 && newlyAssignedTasks.length === 0 && localIdleSessionsChecked === 0 && remoteIdleSessionsChecked === 0 && !autoLaunchStarted
+        ...(autoLaunchPending ? { autoLaunchPending: true } : {}),
+        // Only report "no idle session, go launch one" when nothing is already on its way.
+        // A pending auto-launch (this tick or a prior still-converging one) means a session
+        // WILL claim shortly, so it is not a no-session-available situation.
+        ...(pendingAfter > 0 && newlyAssignedTasks.length === 0 && localIdleSessionsChecked === 0 && remoteIdleSessionsChecked === 0 && !autoLaunchPending
             ? { noIdleMeshSessionAvailable: true }
             : {}),
     };
@@ -1810,7 +1838,26 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             // re-attributed to the latest task (the normal task_completed path below).
             const supersedesWeakTerminal = isWeakTerminalLedgerPayload(terminal.payload)
                 && isGenuineCompletionEvidence(args.metadataEvent);
-            if (!newDispatchAfterTerminal && !supersedesWeakTerminal) {
+            // CANON-B (direct-dispatch completion race): a FAST direct dispatch (mesh_send_task)
+            // to an already-idle, previously-used session can have its genuine completion reach
+            // this coordinator handler BEFORE the dispatching side records the new task's dispatch
+            // row / task_dispatched ledger entry — insertDirectDispatch + appendLedgerEntry both run
+            // AFTER the agent_command await resolves, while the worker may already be done. In that
+            // window sessionHasActiveAssignment is false (no active dispatch row, no unterminal
+            // ledger entry yet), so this prior-terminal dedup engages; and because providerSessionId
+            // is STABLE across a reused session's turns, the providerSessionId/finalSummary match
+            // below would suppress the NEW task's completion as a duplicate of the PRIOR task —
+            // silently losing it (the observed intermittent miss; fresh enqueue/autoLaunch is immune
+            // because a fresh session has no prior same-providerSessionId terminal and the queue row
+            // is claimed atomically before dispatch). The echoed taskId is the authoritative
+            // discriminator: when the completion names a DIFFERENT task than the recorded terminal,
+            // it is a genuinely new task's completion, never a duplicate — let it through so it is
+            // attributed to its own taskId. A same-task re-arrival (taskId equal) or a taskId-less
+            // legacy event still falls through to the providerSessionId/finalSummary dedup.
+            const terminalTaskId = readNonEmptyString(terminal.payload.taskId);
+            const eventTaskId = readNonEmptyString(args.metadataEvent.taskId);
+            const distinctTaskCompletion = !!eventTaskId && !!terminalTaskId && eventTaskId !== terminalTaskId;
+            if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion) {
                 const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
                 const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
                 const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);
@@ -2433,6 +2480,24 @@ function forwardUnresolvedDelegateEvent(
         workspace: readNonEmptyString(routing.workspace) || readNonEmptyString(event.workspace) || undefined,
     };
 
+    // Self-addressed fallback: the resolved coordinator IS this daemon (a self-
+    // coordinating / single-node mesh, or a delegate whose coordinator anchor resolved
+    // to our own id). A cross-daemon mesh_forward_event to our own id is REFUSED by the
+    // dispatch self-dial guard ("route via the local router instead"), so persisting it
+    // to the outbox would only loop forever in PHASE 0's retry, never acked. Honour the
+    // guard's advice: route the event straight through the local receiver — the exact
+    // path the coordinator runs on receiving a remote push — and skip the outbox entirely.
+    const selfDaemonIds = resolveCoordinatorDrainDaemonIds(components);
+    if (selfDaemonIds.some(self => daemonIdsEquivalent(self, coordinatorDaemonId))) {
+        try {
+            handleMeshForwardEvent(components, payload);
+            LOG.info('MeshEvents', `Self-addressed unresolved-delegate ${eventName} routed via local router (coordinator ${coordinatorDaemonId} is self) — outbox skipped`);
+        } catch (e: any) {
+            LOG.warn('MeshEvents', `Local route of self-addressed unresolved-delegate ${eventName} failed: ${e?.message || e}`);
+        }
+        return true;
+    }
+
     // 1) Persist durably FIRST. Idempotent on fingerprint, so a re-fired completion
     //    does not duplicate the outbox row. If persistence fails we still attempt the
     //    push below (degrades to the old at-most-once behaviour rather than dropping

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

@@ -734,6 +734,12 @@ async function retryUnresolvedDelegateForwards(components: DaemonComponents): Pr
     const entries = peekUnresolvedDelegateForwards();
     if (entries.length === 0) return;
 
+    // Every id-form THIS daemon answers to. A self-addressed outbox entry (coordinator
+    // == this daemon) must never be cross-dialled — see the self-route branch below.
+    const selfIds = resolveCoordinatorDaemonIds(components);
+    const isSelfCoordinatorId = (id: string): boolean =>
+        selfIds.some(self => daemonIdsEquivalent(self, id));
+
     for (const entry of entries) {
         // EVTTRACE correlation context for this outbox entry's retry.
         const entryTraceCtx = {
@@ -742,6 +748,38 @@ async function retryUnresolvedDelegateForwards(components: DaemonComponents): Pr
             nodeId: readNonEmptyString(entry.payload.nodeId),
             event: readNonEmptyString(entry.payload.event),
         };
+
+        // Self-addressed forward: the coordinator daemon this entry targets IS this
+        // daemon (a self-coordinating / single-node mesh, or a delegate whose coordinator
+        // anchor resolved to our own id). A cross-daemon mesh_forward_event to our own id
+        // is REFUSED by the dispatch self-dial guard ("Refusing to send ... to this
+        // daemon's own id; route via the local router instead") on every retry, so the
+        // entry can never be acked and loops forever (~every tick), spamming the log and
+        // pinning the outbox row permanently undrained. Honour the guard's own advice:
+        // route the event straight through the local receiver (handleMeshForwardEvent —
+        // the same path the coordinator runs on receiving a remote push), then ack it.
+        // We drain regardless of the local result: a cross-daemon dispatch could not have
+        // resolved it either (the guard rejects before the receiver ever runs), so leaving
+        // it queued only re-spams. handleMeshForwardEvent has the BEST recovery chance —
+        // this daemon hosts the mesh, so its workspace/nodeId → meshId recovery applies.
+        if (isSelfCoordinatorId(entry.coordinatorDaemonId)) {
+            let localResult: any;
+            try {
+                traceMeshEventStage('forward_send', entryTraceCtx, `self → local router (${entry.coordinatorDaemonId})`);
+                localResult = handleMeshForwardEvent(components, entry.payload);
+            } catch (e: any) {
+                LOG.warn('MeshReconcile', `Local route of self-addressed forward to ${entry.coordinatorDaemonId} threw: ${e?.message || e} — draining anyway to break the retry loop`);
+            }
+            ackUnresolvedDelegateForward(entry.id);
+            if (localResult && localResult.success === false) {
+                LOG.warn('MeshReconcile', `Self-addressed unresolved-delegate ${readNonEmptyString(entry.payload.event)} rejected by local router (${readNonEmptyString(localResult.error) || 'no reason'}) — drained to break the self-forward retry loop`);
+                traceMeshEventDrop('self_forward_local_rejected', entryTraceCtx, readNonEmptyString(localResult.error) || 'no reason');
+            } else {
+                LOG.info('MeshReconcile', `Self-addressed unresolved-delegate ${readNonEmptyString(entry.payload.event)} routed via local router (coordinator ${entry.coordinatorDaemonId} is self) — drained`);
+            }
+            continue;
+        }
+
         let result: any;
         try {
             traceMeshEventStage('forward_send', entryTraceCtx, `retry → ${entry.coordinatorDaemonId}`);