@adhdev/daemon-core 0.9.82-rc.371 → 0.9.82-rc.373

package/dist/logging/log-tail-reader.d.ts

@@ -7,7 +7,21 @@
  * grep the file by hand. Because the mesh RPC envelope is sent as a single
  * datachannel message (~256KB SCTP ceiling, no chunking), the returned tail is
  * HARD-bounded by `tailBytes` (default 64KB, capped at MAX_TAIL_BYTES=128KB) and
- * flags `truncated:true` when the file was larger.
+ * flags `truncated:true` when more content existed than fit.
+ *
+ * Two read modes:
+ *  - No filter (no grep/sinceMs): byte-bounded tail of the active file — read the
+ *    last `tailBytes` bytes only. Cheap, backward-compatible.
+ *  - Filtered (grep and/or sinceMs given): FULL-FILE scan. The filter is applied
+ *    across the ENTIRE file (plus the size-rotation `.1.log` backup) BEFORE the
+ *    byte cap, then the last `tailBytes` worth of MATCHING lines are returned.
+ *    This is the fix for "matches hidden behind polling spam": when the recent
+ *    tail window is saturated with high-frequency lines (e.g. coordinator polling
+ *    `get_pending_mesh_events`/`read_chat` every few seconds), a grep for a rarer
+ *    earlier line (dispatch/inject/forward) previously matched 0 because the line
+ *    had already scrolled out of the tail window before the filter ran. Filtering
+ *    the whole file first surfaces those matches regardless of how much unrelated
+ *    spam followed them.
  *
  * Boundary-safe: lines are cut on the newline byte (0x0A) only, which never
  * appears inside a multibyte UTF-8 sequence, so decoding each complete byte
@@ -29,18 +43,39 @@ export interface DaemonLogTailResult {
     success: boolean;
     error?: string;
     lines: string[];
+    /**
+     * No-filter mode: true when the file was larger than the byte window.
+     * Filter mode: true when matching lines were dropped from the FRONT to fit
+     * the byte cap (i.e. there are older matches than the ones returned).
+     */
     truncated: boolean;
     logPath: string;
     platform: NodeJS.Platform;
     bytesReturned: number;
-    /** True when a grep/since filter dropped lines from the raw tail window. */
+    /** True when a grep/since filter dropped at least one line. */
     filtered: boolean;
     /** The grep source actually applied (echoed back for clarity). */
     grep?: string;
+    /** True when the filtered full-file scan path ran (grep/sinceMs given). */
+    fullScan: boolean;
+    /** Total bytes read while scanning (filter mode scans the whole file + backup). */
+    scannedBytes: number;
+    /** Number of lines that matched the filter across the full scan (filter mode). */
+    matchedLineCount: number;
+    /** Number of scanned lines dropped by the filter ("N lines excluded by filter"). */
+    excludedByFilter: number;
 }
 /**
- * Read the daemon log tail for `date` (default today), bounded to `tailBytes`,
- * with optional grep (regex source) and sinceMs filters. Falls back to the
- * size-rotation backup (`*.1.log`) when the primary file does not exist.
+ * Read the daemon log tail for `date` (default today), bounded to `tailBytes`.
+ *
+ * - No grep/sinceMs → byte-bounded tail of the active file (legacy behaviour).
+ * - grep and/or sinceMs given → FULL-FILE scan: the filter is applied across the
+ *   whole file (plus the `*.1.log` size-rotation backup) BEFORE the byte cap, so
+ *   matches that have scrolled out of the recent tail window (e.g. behind
+ *   coordinator polling spam) are still returned. Only the last `tailBytes` worth
+ *   of matching lines ship over P2P.
+ *
+ * Falls back to the size-rotation backup (`*.1.log`) when the primary file does
+ * not exist.
  */
 export declare function readDaemonLogTail(args?: ReadDaemonLogTailArgs): DaemonLogTailResult;

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

@@ -1,5 +1,6 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
+export declare function resolveForwardEventMeshId(components: DaemonComponents, payload: Record<string, unknown>): string;
 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;

package/dist/mesh/mesh-reconcile-loop.d.ts

@@ -1,5 +1,6 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 export declare function runMeshReconcileTick(components: DaemonComponents): Promise<void>;
+export declare function __resetUnresolvedForwardRejectionCountsForTests(): void;
 interface ReconcileLoopHandle {
     stop(): void;
 }

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

@@ -73,6 +73,7 @@ export declare class MeshRuntimeStore {
     claimNextQueueTask(meshId: string, nodeId: string, sessionId: string, capabilityTags?: string[], opts?: {
         providerType?: string;
         providerMaxParallel?: number;
+        nodeIsWorktree?: boolean;
     }): MeshWorkQueueEntry | null;
     getQueueStatsByStatus(meshId: string): {
         status: string;

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

@@ -195,6 +195,7 @@ export declare function getMeshQueueRevision(meshId: string): string;
 export declare function claimNextTask(meshId: string, nodeId: string, sessionId: string, capabilityTags?: string[], opts?: {
     providerType?: string;
     providerMaxParallel?: number;
+    nodeIsWorktree?: boolean;
 }): MeshWorkQueueEntry | null;
 export type DependencyFailurePolicy = 'block' | 'cancel';
 /**

package/package.json

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

package/src/commands/cli-manager.ts

@@ -1215,8 +1215,17 @@ export class DaemonCliManager {
             const adapter = this.adapters.get(ik);
             if (adapter) return { adapter, key: ik };
         }
- // 1. agentType + dir match
-        if (opts?.dir) {
+ // 1. agentType + dir match.
+ //    FAIL-CLOSED when an explicit instanceKey/targetSessionId was named (step 0) but
+ //    did not resolve: the caller pinned a SPECIFIC session, so healing by workspace must
+ //    not silently redirect the command into a co-located SIBLING worktree session. The
+ //    remote mesh relay (ipcDispatchToRemoteAgent) carries `dir: node.workspace` alongside
+ //    targetSessionId for the sessionless-scope case; when a session WAS named, that dir
+ //    fallback is the WTDISPATCH-FANOUT (a) leak — a stale/relaunched session_id would
+ //    dir-match whatever session lives in that workspace instead of failing. The sessionless
+ //    node-scoped path uses findMeshNodeAdapter, not this fallback, so gating dir on
+ //    !instanceKey loses no legitimate routing. Mirror step 2's fail-closed rule.
+        if (opts?.dir && !opts?.instanceKey) {
             for (const [k, a] of this.adapters) {
                 if (a.cliType === agentType && a.workingDir === opts.dir) {
                     return { adapter: a, key: k };

package/src/commands/low-family/mesh-node-logs.ts

@@ -75,6 +75,12 @@ export const meshNodeLogsHandlers: Record<string, LowFamilyHandler> = {
             truncated: tail.truncated,
             filtered: tail.filtered,
             bytesReturned: tail.bytesReturned,
+            // Transparency meta — lets the coordinator see that a full-file grep
+            // ran past the recent tail window, and how much was scanned/excluded.
+            fullScan: tail.fullScan,
+            scannedBytes: tail.scannedBytes,
+            matchedLineCount: tail.matchedLineCount,
+            excludedByFilter: tail.excludedByFilter,
             ...(tail.grep ? { grep: tail.grep } : {}),
         } as CommandRouterResult;
     },

package/src/commands/router.ts

@@ -1216,6 +1216,51 @@ export function buildMeshNodeDataFreshness(args: {
     };
 }
 
+/**
+ * Canonical live-probe → freshness adapter. The coordinator-facing mesh_status
+ * (mcp-server `meshStatus`) builds each node entry from a SINGLE fresh git_status
+ * probe that either returns (live truth) or throws (peer unreachable). It used to
+ * hand-reconstruct the freshness INPUT inline — a synthetic `{ git, connection }`
+ * status plus the directTruthUnavailable/liveTruthProbed wiring — which is exactly
+ * how a field added to `buildMeshNodeDataFreshness`'s input contract ends up "wired
+ * on the daemon surface, null on the coordinator surface" (the rc.371
+ * null-everywhere regression). Routing every live-probe surface through this one
+ * adapter keeps the marker derivation canonical: there is a SINGLE place that turns
+ * a probe outcome into freshness args, so the two mesh_status surfaces cannot drift.
+ *
+ * `liveTruthProbed` true → the probe returned (live/self truth); false → it threw,
+ * so a configured peer is unreachable while an unconfigured node (no daemonId) falls
+ * through to the classifier's `unconfigured` branch.
+ */
+export function buildMeshNodeProbeFreshness(args: {
+    /** The git snapshot this probe stamped on the node entry (entry.git). */
+    git: unknown;
+    /** True when the fresh git_status probe RETURNED (live truth); false when it threw. */
+    liveTruthProbed: boolean;
+    isSelfNode: boolean;
+    /** The node's resolved daemonId; absent → unconfigured node. */
+    daemonId?: string;
+    /** The mesh node record, for held-git fallback when the probe did not return live. */
+    node?: any;
+    now?: () => number;
+}): Record<string, unknown> {
+    const { git, liveTruthProbed, isSelfNode, daemonId, node, now } = args;
+    const status: Record<string, unknown> = {
+        git,
+        connection: { state: liveTruthProbed ? 'connected' : 'disconnected' },
+    };
+    if (liveTruthProbed) status[MESH_NODE_LIVE_TRUTH_MARKER] = true;
+    return buildMeshNodeDataFreshness({
+        status,
+        node,
+        isSelfNode,
+        daemonId,
+        liveTruthProbed,
+        directTruthUnavailable: !liveTruthProbed && !!daemonId,
+        now,
+    });
+}
+
 export function finalizeMeshNodeStatus(args: {
     status: Record<string, unknown>;
     node: any;

package/src/index.ts

@@ -312,7 +312,7 @@ export type { CdpInitializerConfig } from './cdp/initializer.js';
 // ── Commands ──
 export { DaemonCommandHandler } from './commands/handler.js';
 export type { CommandResult, CommandContext } from './commands/handler.js';
-export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails, resolveMeshNodeAttribution, buildMeshNodeDataFreshness, MESH_NODE_LIVE_TRUTH_MARKER } from './commands/router.js';
+export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails, resolveMeshNodeAttribution, buildMeshNodeDataFreshness, buildMeshNodeProbeFreshness, MESH_NODE_LIVE_TRUTH_MARKER } from './commands/router.js';
 export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
 export {
   maybeRunDaemonUpgradeHelperFromEnv,

package/src/logging/log-tail-reader.ts

@@ -7,7 +7,21 @@
  * grep the file by hand. Because the mesh RPC envelope is sent as a single
  * datachannel message (~256KB SCTP ceiling, no chunking), the returned tail is
  * HARD-bounded by `tailBytes` (default 64KB, capped at MAX_TAIL_BYTES=128KB) and
- * flags `truncated:true` when the file was larger.
+ * flags `truncated:true` when more content existed than fit.
+ *
+ * Two read modes:
+ *  - No filter (no grep/sinceMs): byte-bounded tail of the active file — read the
+ *    last `tailBytes` bytes only. Cheap, backward-compatible.
+ *  - Filtered (grep and/or sinceMs given): FULL-FILE scan. The filter is applied
+ *    across the ENTIRE file (plus the size-rotation `.1.log` backup) BEFORE the
+ *    byte cap, then the last `tailBytes` worth of MATCHING lines are returned.
+ *    This is the fix for "matches hidden behind polling spam": when the recent
+ *    tail window is saturated with high-frequency lines (e.g. coordinator polling
+ *    `get_pending_mesh_events`/`read_chat` every few seconds), a grep for a rarer
+ *    earlier line (dispatch/inject/forward) previously matched 0 because the line
+ *    had already scrolled out of the tail window before the filter ran. Filtering
+ *    the whole file first surfaces those matches regardless of how much unrelated
+ *    spam followed them.
  *
  * Boundary-safe: lines are cut on the newline byte (0x0A) only, which never
  * appears inside a multibyte UTF-8 sequence, so decoding each complete byte
@@ -36,14 +50,27 @@ export interface DaemonLogTailResult {
     success: boolean;
     error?: string;
     lines: string[];
+    /**
+     * No-filter mode: true when the file was larger than the byte window.
+     * Filter mode: true when matching lines were dropped from the FRONT to fit
+     * the byte cap (i.e. there are older matches than the ones returned).
+     */
     truncated: boolean;
     logPath: string;
     platform: NodeJS.Platform;
     bytesReturned: number;
-    /** True when a grep/since filter dropped lines from the raw tail window. */
+    /** True when a grep/since filter dropped at least one line. */
     filtered: boolean;
     /** The grep source actually applied (echoed back for clarity). */
     grep?: string;
+    /** True when the filtered full-file scan path ran (grep/sinceMs given). */
+    fullScan: boolean;
+    /** Total bytes read while scanning (filter mode scans the whole file + backup). */
+    scannedBytes: number;
+    /** Number of lines that matched the filter across the full scan (filter mode). */
+    matchedLineCount: number;
+    /** Number of scanned lines dropped by the filter ("N lines excluded by filter"). */
+    excludedByFilter: number;
 }
 
 function resolveLogPath(date?: string | Date): string {
@@ -102,6 +129,39 @@ function readByteBoundedTail(filePath: string, limitBytes: number): { text: stri
     }
 }
 
+/** Split decoded text into lines, dropping the trailing empty element a final
+ * newline produces. Pure helper shared by both read modes. */
+function splitLogLines(text: string): string[] {
+    const lines = text.split('\n');
+    if (lines.length && lines[lines.length - 1] === '') lines.pop();
+    return lines;
+}
+
+/**
+ * Keep the LAST lines whose cumulative UTF-8 byte size (counting one byte per
+ * line for the joining newline) stays within `limitBytes`. Always keeps at least
+ * the final line, even if it alone exceeds the cap (matches the no-filter path's
+ * "never return nothing when there is content" behaviour). `truncated` is true
+ * when earlier lines were dropped to fit.
+ */
+function takeLastLinesWithinBytes(lines: string[], limitBytes: number): { kept: string[]; truncated: boolean; bytesReturned: number } {
+    if (lines.length === 0) return { kept: [], truncated: false, bytesReturned: 0 };
+    let total = 0;
+    let firstKept = lines.length;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const lineBytes = Buffer.byteLength(lines[i], 'utf-8') + 1; // +1 ≈ joining newline
+        // Once at least one line is kept, stop before overflowing the cap.
+        if (firstKept !== lines.length && total + lineBytes > limitBytes) break;
+        total += lineBytes;
+        firstKept = i;
+    }
+    return {
+        kept: lines.slice(firstKept),
+        truncated: firstKept > 0,
+        bytesReturned: total,
+    };
+}
+
 // Parse a leading timestamp from a log line into epoch ms. The unified logger
 // writes `[HH:MM:SS.mmm]` (local time, today's date) and the startup banner uses
 // a full timestamp; we best-effort parse `[HH:MM:SS...]` against the file's date.
@@ -122,99 +182,160 @@ function parseLineEpochMs(line: string, fileDate: Date): number | null {
     return d.getTime();
 }
 
+/** Build the case-insensitive line predicate for a grep source, falling back to
+ * a literal (lowercased substring) match when the source is not a valid regex. */
+function buildGrepPredicate(grepSource: string): (line: string) => boolean {
+    let re: RegExp | null = null;
+    try {
+        re = new RegExp(grepSource, 'i');
+    } catch {
+        re = null;
+    }
+    if (re) {
+        const compiled = re;
+        return (line: string) => compiled.test(line);
+    }
+    const needle = grepSource.toLowerCase();
+    return (line: string) => line.toLowerCase().includes(needle);
+}
+
+function fileDateFor(date?: string | Date): Date {
+    if (date instanceof Date) return date;
+    if (typeof date === 'string' && date.trim()) return new Date(`${date.trim()}T00:00:00.000Z`);
+    return new Date();
+}
+
+function errorResult(error: string, logPath: string, platform: NodeJS.Platform): DaemonLogTailResult {
+    return {
+        success: false,
+        error,
+        lines: [],
+        truncated: false,
+        logPath,
+        platform,
+        bytesReturned: 0,
+        filtered: false,
+        fullScan: false,
+        scannedBytes: 0,
+        matchedLineCount: 0,
+        excludedByFilter: 0,
+    };
+}
+
 /**
- * Read the daemon log tail for `date` (default today), bounded to `tailBytes`,
- * with optional grep (regex source) and sinceMs filters. Falls back to the
- * size-rotation backup (`*.1.log`) when the primary file does not exist.
+ * Read the daemon log tail for `date` (default today), bounded to `tailBytes`.
+ *
+ * - No grep/sinceMs → byte-bounded tail of the active file (legacy behaviour).
+ * - grep and/or sinceMs given → FULL-FILE scan: the filter is applied across the
+ *   whole file (plus the `*.1.log` size-rotation backup) BEFORE the byte cap, so
+ *   matches that have scrolled out of the recent tail window (e.g. behind
+ *   coordinator polling spam) are still returned. Only the last `tailBytes` worth
+ *   of matching lines ship over P2P.
+ *
+ * Falls back to the size-rotation backup (`*.1.log`) when the primary file does
+ * not exist.
  */
 export function readDaemonLogTail(args: ReadDaemonLogTailArgs = {}): DaemonLogTailResult {
     const platform = process.platform;
     const limitBytes = clampTailBytes(args.tailBytes);
-    let logPath = resolveLogPath(args.date);
-
-    // Fall back to the size-rotation backup if the active file is absent.
-    if (!fs.existsSync(logPath)) {
-        const backup = logPath.replace(/\.log$/, '.1.log');
-        if (fs.existsSync(backup)) {
-            logPath = backup;
-        } else {
-            return {
-                success: false,
-                error: `No daemon log file at ${logPath} (dir: ${getDaemonLogDir()})`,
-                lines: [],
-                truncated: false,
-                logPath,
-                platform,
-                bytesReturned: 0,
-                filtered: false,
-            };
-        }
+    const primaryPath = resolveLogPath(args.date);
+    const backupPath = primaryPath.replace(/\.log$/, '.1.log');
+    const primaryExists = fs.existsSync(primaryPath);
+    const backupExists = fs.existsSync(backupPath);
+
+    if (!primaryExists && !backupExists) {
+        return errorResult(
+            `No daemon log file at ${primaryPath} (dir: ${getDaemonLogDir()})`,
+            primaryPath,
+            platform,
+        );
     }
 
-    let raw: { text: string; truncated: boolean; bytesReturned: number };
-    try {
-        raw = readByteBoundedTail(logPath, limitBytes);
-    } catch (e: any) {
+    // Reported log path: the active file when present, else the backup.
+    const logPath = primaryExists ? primaryPath : backupPath;
+
+    const hasGrep = typeof args.grep === 'string' && args.grep.trim().length > 0;
+    const hasSince = Number.isFinite(args.sinceMs);
+    const filterMode = hasGrep || hasSince;
+
+    // ── No-filter mode: cheap byte-bounded tail of the active file ──────────
+    if (!filterMode) {
+        let raw: { text: string; truncated: boolean; bytesReturned: number };
+        try {
+            raw = readByteBoundedTail(logPath, limitBytes);
+        } catch (e: any) {
+            return errorResult(`Failed to read ${logPath}: ${e?.message ?? String(e)}`, logPath, platform);
+        }
+        const lines = splitLogLines(raw.text);
         return {
-            success: false,
-            error: `Failed to read ${logPath}: ${e?.message ?? String(e)}`,
-            lines: [],
-            truncated: false,
+            success: true,
+            lines,
+            truncated: raw.truncated,
             logPath,
             platform,
-            bytesReturned: 0,
+            bytesReturned: raw.bytesReturned,
             filtered: false,
+            fullScan: false,
+            scannedBytes: raw.bytesReturned,
+            matchedLineCount: lines.length,
+            excludedByFilter: 0,
         };
     }
 
-    let lines = raw.text.split('\n');
-    // A trailing newline yields a final empty element — drop it.
-    if (lines.length && lines[lines.length - 1] === '') lines.pop();
-    const rawCount = lines.length;
-
-    // since filter
-    if (Number.isFinite(args.sinceMs)) {
-        const fileDate = args.date instanceof Date
-            ? args.date
-            : typeof args.date === 'string' && args.date.trim()
-                ? new Date(`${args.date.trim()}T00:00:00.000Z`)
-                : new Date();
+    // ── Filter mode: scan the WHOLE file (backup then primary, chronological)
+    // so matches behind a saturated tail window are still found. ────────────
+    let scannedBytes = 0;
+    let allLines: string[] = [];
+    try {
+        for (const p of [backupExists ? backupPath : null, primaryExists ? primaryPath : null]) {
+            if (!p) continue;
+            const buf = fs.readFileSync(p);
+            scannedBytes += buf.length;
+            allLines = allLines.concat(splitLogLines(buf.toString('utf-8')));
+        }
+    } catch (e: any) {
+        return errorResult(`Failed to read ${logPath}: ${e?.message ?? String(e)}`, logPath, platform);
+    }
+
+    const scannedLineCount = allLines.length;
+    let lines = allLines;
+
+    // since filter — keep lines at/after the floor (and lines with no timestamp).
+    if (hasSince) {
+        const fileDate = fileDateFor(args.date);
         const floor = args.sinceMs as number;
         lines = lines.filter((line) => {
             const ts = parseLineEpochMs(line, fileDate);
-            // Keep lines with no parseable timestamp (continuation/stack lines).
             return ts === null || ts >= floor;
         });
     }
 
     // grep filter
     let appliedGrep: string | undefined;
-    if (typeof args.grep === 'string' && args.grep.trim()) {
-        appliedGrep = args.grep.trim();
-        let re: RegExp | null = null;
-        try {
-            re = new RegExp(appliedGrep, 'i');
-        } catch {
-            re = null;
-        }
-        if (re) {
-            const compiled = re;
-            lines = lines.filter((line) => compiled.test(line));
-        } else {
-            // Invalid regex → fall back to a literal substring match.
-            const needle = appliedGrep.toLowerCase();
-            lines = lines.filter((line) => line.toLowerCase().includes(needle));
-        }
+    if (hasGrep) {
+        appliedGrep = (args.grep as string).trim();
+        const matches = buildGrepPredicate(appliedGrep);
+        lines = lines.filter(matches);
     }
 
+    const matchedLineCount = lines.length;
+    const excludedByFilter = scannedLineCount - matchedLineCount;
+
+    // Byte cap applies to the MATCHING lines: keep the newest matches that fit.
+    const capped = takeLastLinesWithinBytes(lines, limitBytes);
+
     return {
         success: true,
-        lines,
-        truncated: raw.truncated,
+        lines: capped.kept,
+        truncated: capped.truncated,
         logPath,
         platform,
-        bytesReturned: raw.bytesReturned,
-        filtered: lines.length !== rawCount,
+        bytesReturned: capped.bytesReturned,
+        filtered: excludedByFilter > 0,
+        fullScan: true,
+        scannedBytes,
+        matchedLineCount,
+        excludedByFilter,
         ...(appliedGrep ? { grep: appliedGrep } : {}),
     };
 }

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

@@ -91,6 +91,51 @@ function recoverMeshIdByNodeId(nodeId: string): string {
     return '';
 }
 
+// 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.
+// That recovery fails when the no_node_binding session's payload has an empty nodeId AND
+// the coordinator's workspace→mesh lookup misses (a worktree clone whose repoIdentity
+// differs / a cache miss) — leaving the reconcile retry rejected with "meshId required"
+// every 4s forever. The worker actually has MORE context than the stripped payload gives
+// the coordinator: it hosts the node as a member and holds the LIVE session, whose
+// settings.meshNodeFor / meshNodeId are authoritative even when they were not stamped
+// onto the original event. Resolve here (worker side) and stamp meshId onto the payload so
+// the coordinator accepts it. Mirrors the receiver's recovery order, then adds the live-
+// session fallback. Returns '' when even the worker cannot resolve it (truly unresolvable —
+// the retry cap then drops it instead of looping). No side effects; safe to call per retry.
+export function resolveForwardEventMeshId(
+    components: DaemonComponents,
+    payload: Record<string, unknown>,
+): string {
+    const direct = readNonEmptyString(payload.meshId);
+    if (direct) return direct;
+    const workspace = readNonEmptyString(payload.workspace);
+    const byWorkspace = workspace ? readNonEmptyString(getCachedMeshByWorkspace(workspace)?.id) : '';
+    if (byWorkspace) return byWorkspace;
+    const byNode = recoverMeshIdByNodeId(readNonEmptyString(payload.nodeId));
+    if (byNode) return byNode;
+    // Live-session fallback: the worker session may carry meshNodeFor / meshNodeId now even
+    // though the original event didn't (a late stamp, or an event that fired before binding).
+    const sessionId = readNonEmptyString(payload.targetSessionId)
+        || readNonEmptyString(payload.sessionId)
+        || readNonEmptyString(payload.instanceId);
+    if (sessionId) {
+        try {
+            const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+            const settings = (state?.settings as Record<string, unknown>) || {};
+            const meshNodeFor = readNonEmptyString(settings.meshNodeFor);
+            if (meshNodeFor) return meshNodeFor;
+            const byStamp = recoverMeshIdByNodeId(readNonEmptyString(settings.meshNodeId));
+            if (byStamp) return byStamp;
+            const sessionWorkspace = readNonEmptyString(state?.workspace);
+            const bySessionWorkspace = sessionWorkspace ? readNonEmptyString(getCachedMeshByWorkspace(sessionWorkspace)?.id) : '';
+            if (bySessionWorkspace) return bySessionWorkspace;
+        } catch { /* best-effort — fall through to unresolved */ }
+    }
+    return '';
+}
+
 export function __resetIdleAutoFastForwardForTests(): void {
     idleAutoFastForwardLastAttempt.clear();
 }
@@ -595,9 +640,15 @@ export function tryAssignQueueTask(
     // claiming session's providerType + node policy are both known, then enforced
     // inside the atomic claim transaction so concurrent claims can't overshoot it.
     const providerMaxParallel = resolveProviderMaxParallel(node?.policy, providerType);
+    // WTDISPATCH-FANOUT: tell the atomic claim whether the claiming node is a worktree
+    // clone so a `convergence` task (base-only: merge → push → cleanup) is refused for
+    // worktree sessions. Without it, every sibling worktree session on this daemon could
+    // claim the same convergence intent and race push/production-deploy (the 4-way fan-out).
+    const nodeIsWorktree = node?.isLocalWorktree === true;
     const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags, {
         providerType,
         ...(providerMaxParallel !== undefined ? { providerMaxParallel } : {}),
+        nodeIsWorktree,
     });
     if (!task) {
         return false;
@@ -1189,6 +1240,11 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                 // dropped a target node whose identity arrived under a different form (a freshly
                 // mesh_clone_node'd worktree), emptying candidateNodes and mislabelling the skip.
                 if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
+                // WTDISPATCH-FANOUT: a convergence task is base-only (it merges/pushes onto
+                // base). Never auto-launch a worktree-clone session for it — that is the very
+                // fan-out the claim guard refuses, so spinning the session up would only waste
+                // a launch that can never claim. Mirrors claimNextQueueTask's convergence gate.
+                if (task.taskMode === 'convergence' && node?.isLocalWorktree === true) return false;
                 // Skip nodes that can never satisfy requiredTags regardless of which provider
                 // from providerPriority is selected. A node satisfies tags if at least one
                 // provider in its priority list would produce matching capability tags.
@@ -2656,15 +2712,23 @@ function forwardUnresolvedDelegateEvent(
     if (!eventName) return false;
 
     // Flat payload mirroring buildForwardPayloadFromPending / what handleMeshForwardEvent
-    // reads. meshId is omitted on purpose — the worker can't resolve it; the coordinator
-    // recovers it from workspace. nodeId/workspace come from the worker envelope so the
-    // coordinator can name and locate the node.
+    // reads. nodeId/workspace come from the worker envelope so the coordinator can name and
+    // locate the node.
     const payload: Record<string, unknown> = {
         ...event,
         event: eventName,
         nodeId: readNonEmptyString(routing.nodeId) || readNonEmptyString(event.meshNodeId) || undefined,
         workspace: readNonEmptyString(routing.workspace) || readNonEmptyString(event.workspace) || undefined,
     };
+    // RECONCILE-MESHID-DROP: stamp meshId when the WORKER can resolve it (member node /
+    // live-session meshNodeFor). Historically omitted "because the worker can't resolve
+    // it", but for a member-hosted node a no_node_binding session's coordinator-side
+    // recovery (empty payload nodeId + workspace cache miss) fails and the retry is
+    // rejected "meshId required" forever. Resolving here makes the forward self-sufficient;
+    // when unresolvable even here it stays absent and the coordinator's own workspace/nodeId
+    // recovery still runs (unchanged), with the retry cap as the loop backstop.
+    const resolvedMeshId = resolveForwardEventMeshId(components, payload);
+    if (resolvedMeshId) payload.meshId = resolvedMeshId;
 
     // Self-addressed fallback: the resolved coordinator IS this daemon (a self-
     // coordinating / single-node mesh, or a delegate whose coordinator anchor resolved