@adhdev/daemon-core 0.9.82-rc.291 → 0.9.82-rc.293

package/src/commands/router.ts

@@ -31,6 +31,8 @@ import {
     normalizeGitStatus as sharedNormalizeGitStatus,
     pickBestTransitGitStatus as sharedPickBestTransitGitStatus,
     summarizeGitShape as sharedSummarizeGitShape,
+    normalizeMeshNodeId,
+    meshNodeIdMatches,
 } from '@adhdev/mesh-shared';
 import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
@@ -161,7 +163,10 @@ function summarizeRepoMeshStatusDebug(status: any): Record<string, unknown> {
         branchConvergenceSummary: status?.branchConvergenceSummary ?? status?.branch_convergence_summary ?? null,
         nodeCount: nodes.length,
         nodes: nodes.map((node: any) => ({
-            nodeId: readStringValue(node?.nodeId, node?.id) ?? null,
+            // Status emits the id under `nodeId` (3-way input absorbed). The
+            // inline cache keeps `id` and `nodeId` equal, so this serialized form
+            // round-trips back through the cache without flipping shape.
+            nodeId: normalizeMeshNodeId(node) ?? null,
             daemonId: readStringValue(node?.daemonId, node?.daemon_id) ?? null,
             workspace: readStringValue(node?.workspace, node?.git?.workspace) ?? null,
             health: readStringValue(node?.health) ?? null,
@@ -476,7 +481,49 @@ function inlineMeshCarriesTransientNodeTruth(inlineMesh: any): boolean {
 }
 
 function readInlineMeshNodeId(node: any): string {
-    return readStringValue(node?.id, node?.nodeId) || '';
+    // 3-way (id / nodeId / node_id) via the shared normalizer. The old 2-way
+    // `id ?? nodeId` dropped the SQLite `node_id` form, so an inline-cached node
+    // that arrived in that form failed to reconcile against its cached twin.
+    return normalizeMeshNodeId(node) ?? '';
+}
+
+// Boundary normalization: reconcile a node's identity so `id` and `nodeId` both
+// carry the same canonical value (any incoming form — id / nodeId / node_id — is
+// absorbed by normalizeMeshNodeId, and the SQLite `node_id` leak is dropped).
+// See foldMeshNodeIdentityToCanonical for why both fields are kept equal rather
+// than collapsing to one. The rewrite is shallow (other runtime fields are
+// preserved); records that already agree are returned unchanged so
+// identity-equality fast paths hold.
+function foldMeshNodeIdentityToCanonical(node: any): any {
+    if (!node || typeof node !== 'object' || Array.isArray(node)) return node;
+    const canonical = normalizeMeshNodeId(node);
+    if (canonical === undefined) return node;
+    // Save-boundary identity folding, applied IN PLACE. We DUAL-WRITE both `id`
+    // and `nodeId` to the single canonical value (and drop the SQLite `node_id`
+    // leak), rather than collapsing to one field. Two halves of the system read
+    // different field names: the mesh_status serializer emits `nodeId`, while the
+    // worktree clone path and get_mesh membership consumers read `node.id`.
+    // Folding to ONE form would break whichever side reads the other. Keeping
+    // both fields equal makes every reader correct AND makes the
+    // snapshot→cache→reconcile→snapshot round-trip form-stable (no field ever
+    // flips, because both always agree). Mutating in place (not returning a new
+    // object) preserves the cached node-object identity that callers warming an
+    // inline mesh from an already-shared snapshot rely on.
+    if (node.id === canonical && node.nodeId === canonical && node.node_id === undefined) return node;
+    node.id = canonical;
+    node.nodeId = canonical;
+    if ('node_id' in node) delete node.node_id;
+    return node;
+}
+
+function normalizeInlineMeshNodeIdentity(inlineMesh: any): any {
+    if (!inlineMesh || typeof inlineMesh !== 'object' || Array.isArray(inlineMesh)) return inlineMesh;
+    if (!Array.isArray(inlineMesh.nodes) || inlineMesh.nodes.length === 0) return inlineMesh;
+    // Fold each node IN PLACE so the mesh object and its nodes array keep their
+    // identity — sanitizeInlineMesh and the cache-sharing callers depend on
+    // unchanged inputs returning the same reference.
+    for (const node of inlineMesh.nodes) foldMeshNodeIdentityToCanonical(node);
+    return inlineMesh;
 }
 
 function sanitizeInlineMesh(inlineMesh: any): any {
@@ -603,7 +650,7 @@ function deriveMeshNodeHealthFromGit(git: Record<string, unknown> | null | undef
 }
 
 function readMeshNodeLabel(status: Record<string, unknown>, node: any): string {
-    return readStringValue(status.nodeId, node?.id, node?.nodeId) ?? 'unknown';
+    return readStringValue(status.nodeId, normalizeMeshNodeId(node)) ?? 'unknown';
 }
 
 function buildInlineMeshBranchConvergence(args: {
@@ -946,7 +993,7 @@ async function hydrateInlineMeshDirectTruth(args: {
     const unavailableNodeIds: string[] = [];
 
     for (const [nodeIndex, node] of nodes.entries()) {
-        const nodeId = readStringValue(node?.id, node?.nodeId) || `node_${nodeIndex}`;
+        const nodeId = normalizeMeshNodeId(node) || `node_${nodeIndex}`;
         const workspace = readStringValue(node?.workspace);
         const daemonId = readStringValue(node?.daemonId);
         const isSelfNode = Boolean(
@@ -1122,7 +1169,7 @@ function buildHistoricalMeshSessions(args: {
     const liveWorkspaces = new Set<string>();
     const missingLocalWorktreeNodeIds = new Set<string>();
     for (const node of args.nodes || []) {
-        const nodeId = readStringValue(node?.id, node?.nodeId);
+        const nodeId = normalizeMeshNodeId(node);
         const workspace = readStringValue(node?.workspace);
         if (nodeId) liveNodeIds.add(nodeId);
         if (workspace) liveWorkspaces.add(workspace);
@@ -1497,9 +1544,24 @@ function resolveRefineryAutoPublishSubmoduleMainCommits(mesh: any, workspace: st
     return { enabled: false };
 }
 
-async function computeGitPatchId(cwd: string, fromRef: string, toRef: string): Promise<string> {
+async function computeGitPatchId(
+    cwd: string,
+    fromRef: string,
+    toRef: string,
+    excludePaths: string[] = [],
+): Promise<string> {
     const { execFileSync } = await import('node:child_process');
-    const diff = execFileSync('git', ['diff', '--patch', '--full-index', fromRef, toRef], {
+    // When excludePaths is non-empty we drop those paths from the diff via
+    // `:(exclude)` pathspecs. This is used to omit gitlink paths that have
+    // already been proven a safe fast-forward: their patch hunks legitimately
+    // differ between the expected (mergeBase→branch) and actual (base→merged)
+    // diffs because base may have advanced the same gitlink, so comparing them
+    // would spuriously fail patch-equivalence even though the merge is sound.
+    const diffArgs = ['diff', '--patch', '--full-index', fromRef, toRef];
+    if (excludePaths.length > 0) {
+        diffArgs.push('--', '.', ...excludePaths.map(path => `:(exclude)${path}`));
+    }
+    const diff = execFileSync('git', diffArgs, {
         cwd,
         encoding: 'utf8',
         maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
@@ -1514,7 +1576,7 @@ async function computeGitPatchId(cwd: string, fromRef: string, toRef: string): P
     return patchId.split(/\s+/)[0] || '';
 }
 
-async function runMeshRefinePatchEquivalenceGate(
+export async function runMeshRefinePatchEquivalenceGate(
     repoRoot: string,
     baseHead: string,
     branchHead: string,
@@ -1582,8 +1644,25 @@ async function runMeshRefinePatchEquivalenceGate(
                 gitlinkTrivialFastForward,
             };
         }
-        const expectedPatchId = await computeGitPatchId(repoRoot, mergeBase, branchHead);
-        const actualPatchId = await computeGitPatchId(repoRoot, baseHead, mergedTree);
+        // Exclude *proven fast-forward* gitlink paths from BOTH patch-ids. When
+        // base has advanced a submodule pointer (a sibling merged into main ahead
+        // of us) the gitlink hunk's old-value differs between the expected diff
+        // (mergeBase→branch, showing the full base→branch advance) and the actual
+        // diff (base→merged, showing only the shorter advanced-base→branch
+        // advance). That mismatch would spuriously fail equivalence even though
+        // advancing the pointer to the branch side is a provably safe
+        // fast-forward — this is the root cause of the diverged-base
+        // patch_equivalence_failed misjudgment.
+        //
+        // We exclude ONLY gitlinks whose base-side commit is an ancestor of the
+        // branch-side commit (a strict ff, both objects available locally). A
+        // non-ff or ambiguous gitlink (a genuine submodule divergence, or objects
+        // not fetched locally) is deliberately left in the diff so its differing
+        // hunk still drives the comparison — this preserves the original behavior
+        // and prevents a false pass on a real divergence.
+        const ffGitlinkExcludePaths = collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead);
+        const expectedPatchId = await computeGitPatchId(repoRoot, mergeBase, branchHead, ffGitlinkExcludePaths);
+        const actualPatchId = await computeGitPatchId(repoRoot, baseHead, mergedTree, ffGitlinkExcludePaths);
         const equivalent = expectedPatchId === actualPatchId;
         return {
             status: equivalent ? 'passed' : 'failed',
@@ -1871,6 +1950,24 @@ function readChangedPathKinds(repoRoot: string, fromRef: string, toRef: string):
     }
 }
 
+/**
+ * Return the changed gitlink paths between base and branch whose advance is a
+ * strict fast-forward (the base-side commit is an ancestor of the branch-side
+ * commit inside that submodule's repo). These are the paths whose patch-id hunk
+ * may legitimately differ when base has advanced the same submodule, so they
+ * are safe to exclude from the patch-equivalence comparison. A non-ff (genuinely
+ * diverged) gitlink is deliberately excluded from this set so it still fails the
+ * gate.
+ */
+export function collectFastForwardGitlinkPaths(repoRoot: string, baseHead: string, branchHead: string): string[] {
+    return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter(path => {
+        const baseCommit = readTreeObject(repoRoot, baseHead, path);
+        const branchCommit = readTreeObject(repoRoot, branchHead, path);
+        if (!baseCommit || !branchCommit) return false;
+        return isSubmoduleFastForward(pathResolve(repoRoot, path), baseCommit, branchCommit);
+    });
+}
+
 /**
  * Decide whether a merge-tree submodule conflict between base and branch is a
  * trivial gitlink fast-forward (and nothing else).
@@ -1955,12 +2052,64 @@ export function evaluateGitlinkTrivialFastForward(
 }
 
 /**
- * Synthesize the merge result for a trivial gitlink fast-forward: take
- * `baseHead`'s tree and overlay each changed gitlink's branch-side commit.
- * This mirrors what `git merge-tree` would have produced had it not bailed on
- * the submodule recursion limitation. Returns the tree SHA, or undefined on
- * failure. Caller must have already proven (via evaluateGitlinkTrivialFastForward)
- * that every changed gitlink fast-forwards and no other path conflicts.
+ * Build a tree identical to `commitish`'s tree except every gitlink in `paths`
+ * is rewritten to `placeholderCommit`. Used to neutralize submodule pointers so
+ * `git merge-tree` stops bailing on the "Recursive merging with submodules"
+ * limitation and can 3-way merge the surrounding regular-file content. Returns
+ * the tree SHA, or undefined on failure.
+ */
+function buildTreeWithGitlinksEqualized(
+    repoRoot: string,
+    commitish: string,
+    paths: string[],
+    placeholderCommit: string,
+): string | undefined {
+    try {
+        const tree = execFileSync('git', ['rev-parse', `${commitish}^{tree}`], {
+            cwd: repoRoot, encoding: 'utf8', maxBuffer: 1024 * 1024,
+        }).trim();
+        if (!tree) return undefined;
+        const updates = paths.map(path => `160000 commit ${placeholderCommit}\t${path}`).join('\n');
+        if (!updates) return tree;
+        const tmpIndex = pathJoin(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+        const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
+        try {
+            execFileSync('git', ['read-tree', tree], { cwd: repoRoot, env, stdio: 'ignore' });
+            execFileSync('git', ['update-index', '--index-info'], {
+                cwd: repoRoot, env, input: `${updates}\n`, encoding: 'utf8',
+                stdio: ['pipe', 'ignore', 'ignore'],
+            });
+            const newTree = execFileSync('git', ['write-tree'], { cwd: repoRoot, env, encoding: 'utf8' }).trim();
+            return newTree || undefined;
+        } finally {
+            try { fs.rmSync(tmpIndex, { force: true }); } catch { /* ignore */ }
+        }
+    } catch {
+        return undefined;
+    }
+}
+
+/**
+ * Synthesize the merge result for a trivial gitlink fast-forward.
+ *
+ * `git merge-tree` bails whenever a gitlink differs across base/branch even
+ * when the advance is a strict fast-forward, so we synthesize the result it
+ * *would* have produced. Crucially, when the merge-base of base and branch is
+ * NOT `baseHead` (i.e. base has diverged — a sibling was merged into main
+ * ahead of us), `baseHead`'s tree does not contain our branch's own
+ * non-gitlink changes. Simply overlaying gitlinks onto `baseHead`'s tree would
+ * therefore drop those changes and break patch-equivalence.
+ *
+ * To handle the diverged case correctly we run a REAL 3-way merge of the
+ * regular-file content (with the conflicting gitlinks temporarily equalized to
+ * a common placeholder so merge-tree won't bail), then overlay each changed
+ * gitlink's branch-side commit onto the merged result. This preserves both
+ * sides' non-gitlink changes.
+ *
+ * Returns the tree SHA, or undefined on failure / genuine non-gitlink
+ * conflict. Caller must have already proven (via
+ * evaluateGitlinkTrivialFastForward) that every changed gitlink fast-forwards
+ * and no other path conflicts.
  */
 function synthesizeTrivialFastForwardMergeTree(
     repoRoot: string,
@@ -1969,21 +2118,67 @@ function synthesizeTrivialFastForwardMergeTree(
     gitlinks: Array<{ path: string; branchCommit?: string }>,
 ): string | undefined {
     try {
-        const baseTree = execFileSync('git', ['rev-parse', `${baseHead}^{tree}`], {
-            cwd: repoRoot,
-            encoding: 'utf8',
-            maxBuffer: 1024 * 1024,
+        const branchGitlinks = gitlinks.filter(entry => entry.branchCommit);
+        const gitlinkPaths = branchGitlinks.map(entry => entry.path);
+
+        // Establish the regular-file content of the merge via a real 3-way merge
+        // with the conflicting gitlinks neutralized. The placeholder is the
+        // merge-base's value for a gitlink (or, failing that, any branch-side
+        // commit) — it only needs to be identical across all three trees.
+        const mergeBase = execFileSync('git', ['merge-base', baseHead, branchHead], {
+            cwd: repoRoot, encoding: 'utf8', maxBuffer: 1024 * 1024,
         }).trim();
-        if (!baseTree) return undefined;
-        const updates = gitlinks
-            .filter(entry => entry.branchCommit)
+
+        let mergedContentTree: string | undefined;
+        if (mergeBase && gitlinkPaths.length > 0) {
+            const placeholder = readTreeObject(repoRoot, mergeBase, gitlinkPaths[0])
+                || branchGitlinks[0].branchCommit!;
+            const baseEqTree = buildTreeWithGitlinksEqualized(repoRoot, mergeBase, gitlinkPaths, placeholder);
+            const oursEqTree = buildTreeWithGitlinksEqualized(repoRoot, baseHead, gitlinkPaths, placeholder);
+            const theirsEqTree = buildTreeWithGitlinksEqualized(repoRoot, branchHead, gitlinkPaths, placeholder);
+            if (baseEqTree && oursEqTree && theirsEqTree) {
+                try {
+                    // merge-tree --write-tree needs commits (to derive a merge-base);
+                    // synthesize ours/theirs as children of a common base commit.
+                    const baseEqCommit = execFileSync('git', ['commit-tree', baseEqTree, '-m', 'refine-ff-base'], {
+                        cwd: repoRoot, encoding: 'utf8', maxBuffer: 1024 * 1024,
+                    }).trim();
+                    const oursEqCommit = execFileSync('git', ['commit-tree', oursEqTree, '-p', baseEqCommit, '-m', 'refine-ff-ours'], {
+                        cwd: repoRoot, encoding: 'utf8', maxBuffer: 1024 * 1024,
+                    }).trim();
+                    const theirsEqCommit = execFileSync('git', ['commit-tree', theirsEqTree, '-p', baseEqCommit, '-m', 'refine-ff-theirs'], {
+                        cwd: repoRoot, encoding: 'utf8', maxBuffer: 1024 * 1024,
+                    }).trim();
+                    const mergeOut = execFileSync('git', ['merge-tree', '--write-tree', oursEqCommit, theirsEqCommit], {
+                        cwd: repoRoot, encoding: 'utf8', maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+                    }).trim();
+                    mergedContentTree = mergeOut.split(/\s+/)[0] || undefined;
+                } catch {
+                    // A real conflict in the equalized merge means a genuine
+                    // non-gitlink content conflict the evaluator did not foresee
+                    // (or unavailable objects). Fall through to the simple synth.
+                    mergedContentTree = undefined;
+                }
+            }
+        }
+
+        // Fallback: when there is no diverged base (merge-base === baseHead) the
+        // regular-file content of the merge is exactly baseHead's tree, so just
+        // overlay the gitlinks. Also used when the real merge could not run.
+        const contentTree = mergedContentTree
+            || execFileSync('git', ['rev-parse', `${baseHead}^{tree}`], {
+                cwd: repoRoot, encoding: 'utf8', maxBuffer: 1024 * 1024,
+            }).trim();
+        if (!contentTree) return undefined;
+
+        const updates = branchGitlinks
             .map(entry => `160000 commit ${entry.branchCommit}\t${entry.path}`)
             .join('\n');
-        if (!updates) return baseTree;
+        if (!updates) return contentTree;
         const tmpIndex = pathJoin(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
         const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
-            execFileSync('git', ['read-tree', baseTree], { cwd: repoRoot, env, stdio: 'ignore' });
+            execFileSync('git', ['read-tree', contentTree], { cwd: repoRoot, env, stdio: 'ignore' });
             execFileSync('git', ['update-index', '--index-info'], {
                 cwd: repoRoot,
                 env,
@@ -2787,7 +2982,7 @@ function buildMemberJoinNode(mesh: any, args: any, fallbackDaemonId?: string): R
         : null;
     const configured = Array.isArray(mesh?.nodes)
         ? (requestedNodeId
-            ? mesh.nodes.find((node: any) => node?.id === requestedNodeId || node?.nodeId === requestedNodeId)
+            ? mesh.nodes.find((node: any) => meshNodeIdMatches(node, requestedNodeId))
             : mesh.nodes[0])
         : null;
     const source = explicit || configured;
@@ -2859,7 +3054,7 @@ export class DaemonCommandRouter {
         }
 
         const nodes = snapshot.nodes.map((statusNode: any) => {
-            const nodeId = readStringValue(statusNode?.nodeId, statusNode?.id);
+            const nodeId = normalizeMeshNodeId(statusNode);
             const inlineNode = nodeId ? inlineNodesById.get(nodeId) : undefined;
             if (!inlineNode) return statusNode;
             const liveGit = buildInlineMeshTransitGitStatus(inlineNode);
@@ -2987,7 +3182,10 @@ export class DaemonCommandRouter {
 
     private warmInlineMeshCache(meshId: string, inlineMesh?: unknown): any | undefined {
         if (!inlineMesh || typeof inlineMesh !== 'object') return undefined;
-        const sanitizedInlineMesh = sanitizeInlineMesh(inlineMesh as any);
+        // Save-boundary node-id normalization: reconcile each node's identity so
+        // `id` and `nodeId` agree before it enters the cache, so reconcile keys
+        // and the round-trip through the status serializer stay form-stable.
+        const sanitizedInlineMesh = sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh as any));
         const cached = this.inlineMeshCache.get(meshId);
         if (cached) {
             const merged = reconcileInlineMeshCache(cached, sanitizedInlineMesh);
@@ -3009,7 +3207,7 @@ export class DaemonCommandRouter {
             if (cached) {
                 if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
                     const merged = reconcileInlineMeshCache(cached, inlineMesh as any);
-                    this.inlineMeshCache.set(meshId, sanitizeInlineMesh(merged));
+                    this.inlineMeshCache.set(meshId, sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(merged)));
                     return { mesh: merged, inline: true, source: 'inline_cache' };
                 }
                 return { mesh: cached, inline: true, source: 'inline_cache' };
@@ -3048,18 +3246,25 @@ export class DaemonCommandRouter {
     }
 
     private updateInlineMeshNode(meshId: string, mesh: any, node: any): void {
-        if (!mesh || !Array.isArray(mesh.nodes) || !node?.id) return;
-        const idx = mesh.nodes.findIndex((entry: any) => entry?.id === node.id || entry?.nodeId === node.id);
+        const incomingId = normalizeMeshNodeId(node);
+        if (!mesh || !Array.isArray(mesh.nodes) || !incomingId) return;
+        const idx = mesh.nodes.findIndex((entry: any) => meshNodeIdMatches(entry, incomingId));
         if (idx >= 0) mesh.nodes[idx] = node;
         else mesh.nodes.push(node);
         mesh.updatedAt = new Date().toISOString();
+        // Canonicalize node identity in place (id and nodeId kept equal): clone
+        // nodes are created with `id` and re-inserted here (bypassing
+        // warmInlineMeshCache), so this is a second save boundary. In-place
+        // folding preserves the caller's `mesh` / nodes-array references, which
+        // persistWorktreeSetupState reuses across subsequent calls.
+        for (const entry of mesh.nodes) foldMeshNodeIdentityToCanonical(entry);
         this.inlineMeshCache.set(meshId, mesh);
         this.invalidateAggregateMeshStatus(meshId);
     }
 
     private removeInlineMeshNode(meshId: string, mesh: any, nodeId: string): boolean {
         if (!mesh || !Array.isArray(mesh.nodes)) return false;
-        const idx = mesh.nodes.findIndex((entry: any) => entry?.id === nodeId || entry?.nodeId === nodeId);
+        const idx = mesh.nodes.findIndex((entry: any) => meshNodeIdMatches(entry, nodeId));
         if (idx === -1) return false;
         mesh.nodes.splice(idx, 1);
         mesh.updatedAt = new Date().toISOString();
@@ -3105,7 +3310,7 @@ export class DaemonCommandRouter {
 
         const worktreeExists = fs.existsSync(workspace);
         const sourceNode = args.node?.clonedFromNodeId
-            ? args.mesh?.nodes?.find((n: any) => n.id === args.node.clonedFromNodeId || n.nodeId === args.node.clonedFromNodeId)
+            ? args.mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, args.node.clonedFromNodeId))
             : args.mesh?.nodes?.find((n: any) => !n.isLocalWorktree);
         const repoRoot = typeof sourceNode?.repoRoot === 'string' && sourceNode.repoRoot.trim()
             ? sourceNode.repoRoot.trim()
@@ -3865,7 +4070,7 @@ export class DaemonCommandRouter {
             // preferInline: same as startMeshRefineJob — inline-cache-only clone nodes must resolve.
             const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
             const mesh = meshRecord?.mesh;
-            const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+            const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
             if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh`, refineStages };
 
             if (!node.isLocalWorktree || !node.workspace) {
@@ -3873,7 +4078,7 @@ export class DaemonCommandRouter {
             }
 
             const sourceNode = node.clonedFromNodeId
-                ? mesh?.nodes.find((n: any) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId)
+                ? mesh?.nodes.find((n: any) => meshNodeIdMatches(n, node.clonedFromNodeId))
                 : mesh?.nodes.find((n: any) => !n.isLocalWorktree);
             const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
             if (!repoRoot) return { success: false, error: 'Source node repoRoot not found', refineStages };
@@ -4586,7 +4791,7 @@ export class DaemonCommandRouter {
             const missing: string[] = [];
             const nonWorktree: string[] = [];
             for (const nodeId of requestedNodeIds) {
-                const node = allNodes.find(n => n.id === nodeId || n.nodeId === nodeId);
+                const node = allNodes.find(n => meshNodeIdMatches(n, nodeId));
                 if (!node) { missing.push(nodeId); continue; }
                 if (!isConvergeable(node)) { nonWorktree.push(nodeId); continue; }
                 targetNodes.push(node);
@@ -4615,7 +4820,7 @@ export class DaemonCommandRouter {
         // Resolve the base repo root and a base ref to analyze change areas against.
         const resolveRepoRootFor = (node: any): string | undefined => {
             const sourceNode = node.clonedFromNodeId
-                ? allNodes.find(n => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId)
+                ? allNodes.find(n => meshNodeIdMatches(n, node.clonedFromNodeId))
                 : allNodes.find(n => !n.isLocalWorktree);
             return sourceNode?.repoRoot || sourceNode?.workspace;
         };
@@ -4701,7 +4906,7 @@ export class DaemonCommandRouter {
 
         const ordering = orderMeshRefineBatchNodes(changeAreas);
         const orderedNodes = ordering.order
-            .map(nodeId => targetNodes.find(n => n.id === nodeId || n.nodeId === nodeId))
+            .map(nodeId => targetNodes.find(n => meshNodeIdMatches(n, nodeId)))
             .filter((n): n is any => !!n);
 
         const dryRun = args?.dryRun !== false && args?.execute !== true;
@@ -5039,7 +5244,7 @@ export class DaemonCommandRouter {
         const mesh = meshRecord?.mesh;
         const allNodes: any[] = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
         const orderedNodes = nodeIds
-            .map(id => allNodes.find(n => n.id === id || n.nodeId === id))
+            .map(id => allNodes.find(n => meshNodeIdMatches(n, id)))
             .filter((n): n is any => !!n);
         if (orderedNodes.length === 0) {
             return { success: false, error: 'Batch nodes no longer resolvable in mesh', batch: true };
@@ -5198,7 +5403,7 @@ export class DaemonCommandRouter {
         // config-first and misses nodes that only live in the inline cache.
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
         const mesh = meshRecord?.mesh;
-        const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+        const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
         if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
         if (!node.isLocalWorktree || !node.workspace) return { success: false, error: `Refinery requires a local worktree node` };
 
@@ -5282,7 +5487,7 @@ export class DaemonCommandRouter {
                         const { getMesh } = await import('../config/mesh-config.js');
                         const meshObj = getMesh(meshId) ?? this.getCachedInlineMesh(meshId);
                         const nodeObj = Array.isArray(meshObj?.nodes)
-                            ? meshObj.nodes.find((n: any) => n.id === meshNodeId || n.nodeId === meshNodeId)
+                            ? meshObj.nodes.find((n: any) => meshNodeIdMatches(n, meshNodeId))
                             : undefined;
                         const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
                         if (bootstrapStatus === 'running') {
@@ -5339,7 +5544,7 @@ export class DaemonCommandRouter {
                         const { getMesh } = await import('../config/mesh-config.js');
                         const meshObj = getMesh(dispatchMeshId) ?? this.getCachedInlineMesh(dispatchMeshId);
                         const nodeObj = Array.isArray(meshObj?.nodes)
-                            ? meshObj.nodes.find((n: any) => n.id === dispatchNodeId || n.nodeId === dispatchNodeId)
+                            ? meshObj.nodes.find((n: any) => meshNodeIdMatches(n, dispatchNodeId))
                             : undefined;
                         const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
                         if (bootstrapStatus === 'running') {
@@ -6778,7 +6983,7 @@ export class DaemonCommandRouter {
                     const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
                     const mesh = meshRecord?.mesh;
                     if (!mesh) return { success: false, error: 'Mesh not found' };
-                    const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+                    const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
                     if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
                     const mode = this.normalizeMeshSessionCleanupMode(args?.mode ?? mesh?.policy?.sessionCleanupOnNodeRemove);
                     const sessionIds = Array.isArray(args?.sessionIds)
@@ -6844,7 +7049,7 @@ export class DaemonCommandRouter {
                 // preferInline: plan is the dry-run sibling of refine — clone nodes must resolve.
                 const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
                 const mesh = meshRecord?.mesh;
-                const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+                const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
                 if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
                 return {
                     success: true,
@@ -6870,7 +7075,7 @@ export class DaemonCommandRouter {
                     // preferInline so fast-forward can resolve inline-cache-only clone worktree nodes.
                     const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
                     const mesh = meshRecord?.mesh;
-                    const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+                    const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
                     if (!workspace) {
                         workspace = typeof node?.workspace === 'string' ? node.workspace.trim() : '';
                     }
@@ -6923,7 +7128,7 @@ export class DaemonCommandRouter {
                     // preferInline: plan is the dry-run sibling of refine — clone nodes must resolve.
                     const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
                     const mesh = meshRecord?.mesh;
-                    const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+                    const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
                     if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
                     return {
                         success: true,
@@ -6963,7 +7168,7 @@ export class DaemonCommandRouter {
                     // preferInline so removal can resolve inline-cache-only clone worktree nodes.
                     const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
                     const mesh = meshRecord?.mesh;
-                    const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+                    const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
 
                     // Guard: refuse to remove the coordinator's OWN local base node
                     // (same machine, NOT a worktree). Removing it breaks live mesh
@@ -7115,7 +7320,7 @@ export class DaemonCommandRouter {
                     const mesh = meshRecord?.mesh;
                     if (!mesh) return { success: false, error: 'Mesh not found' };
 
-                    const sourceNode = mesh.nodes?.find((n: any) => n.id === sourceNodeId || n.nodeId === sourceNodeId);
+                    const sourceNode = mesh.nodes?.find((n: any) => meshNodeIdMatches(n, sourceNodeId));
                     if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
 
                     // Forward to the source node's daemon if it's on a different machine.
@@ -7390,7 +7595,7 @@ export class DaemonCommandRouter {
                     const mesh = meshRecord?.mesh;
                     if (!mesh) return { success: false, error: 'Mesh not found' };
 
-                    const node = mesh.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+                    const node = mesh.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
                     if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
                     if (!node.isLocalWorktree) return { success: false, error: 'Node is not a local worktree node' };
 
@@ -7566,14 +7771,14 @@ export class DaemonCommandRouter {
                     const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
                     const workspace = readLiveMeshNodeWorkspace({
                         meshId,
-                        nodeId: String(coordinatorNode.id || coordinatorNode.nodeId || preferredCoordinatorNodeId || ''),
+                        nodeId: String(normalizeMeshNodeId(coordinatorNode) || preferredCoordinatorNodeId || ''),
                         liveSessionRecords: liveMeshSessions,
                         allowCoordinatorSession: true,
                     }) || (typeof coordinatorNode.workspace === 'string' ? coordinatorNode.workspace.trim() : '');
                     if (!workspace) return { success: false, error: 'Coordinator node workspace required', meshId, cliType };
                     if (!cliType) {
                         const resolved = await resolveProviderTypeFromPriority({
-                            nodeId: String(coordinatorNode.id || coordinatorNode.nodeId || preferredCoordinatorNodeId || 'coordinator'),
+                            nodeId: String(normalizeMeshNodeId(coordinatorNode) || preferredCoordinatorNodeId || 'coordinator'),
                             providerPriority: readProviderPriorityFromPolicy(coordinatorNode.policy),
                             providerLoader: this.deps.providerLoader,
                             onStatusChange: this.deps.onStatusChange,
@@ -8062,6 +8267,13 @@ export class DaemonCommandRouter {
                     const meshHost = resolveMeshHostStatus(mesh);
 
                     const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+                    // Compact (default) elides each mission's full goal text from the
+                    // payload — coordinators polling node health don't need every
+                    // mission's multi-hundred-char goal repeated. verbose=true (or the
+                    // explicit compact=false) restores full goals. Verbose bypasses the
+                    // shared (compact) aggregate cache so a verbose call never poisons
+                    // the compact cache and vice versa.
+                    const verboseMissions = args?.verbose === true || args?.compact === false;
                     // See (B3) below: scope the peek to this daemon when the
                     // caller doesn't tell us, otherwise scoped events look
                     // missing and we falsely return a stale cache.
@@ -8070,7 +8282,7 @@ export class DaemonCommandRouter {
                         : (this.deps.statusInstanceId || undefined);
                     const pendingCoordinatorEventCount = getPendingMeshCoordinatorEvents(meshId, peekScope).length;
                     const hadAggregateCache = this.aggregateMeshStatusCache.has(meshId);
-                    if (!refreshRequested && pendingCoordinatorEventCount === 0) {
+                    if (!refreshRequested && !verboseMissions && pendingCoordinatorEventCount === 0) {
                         const cachedStatus = this.getCachedAggregateMeshStatus(meshId, mesh, { requireDirectPeerTruth: args?.requireDirectPeerTruth === true });
                         if (cachedStatus) {
                             logRepoMeshStatusDebug('return_cached', {
@@ -8133,7 +8345,7 @@ export class DaemonCommandRouter {
                     const unavailableNodesAreOnlyRemovedWorktrees = unavailableDirectTruthNodeIds.size > 0
                         && Array.isArray(mesh.nodes)
                         && mesh.nodes
-                            .filter((node: any) => unavailableDirectTruthNodeIds.has(String(node.id || node.nodeId || '')))
+                            .filter((node: any) => unavailableDirectTruthNodeIds.has(normalizeMeshNodeId(node) ?? ''))
                             .every((node: any) => node?.isLocalWorktree === true);
                     const directTruthSatisfied = !requireDirectPeerTruth
                         || (effectiveDirectTruth.directEvidenceCount > 0 && (effectiveDirectTruth.unavailableNodeIds.length === 0 || unavailableNodesAreOnlyRemovedWorktrees));
@@ -8174,8 +8386,7 @@ export class DaemonCommandRouter {
                     const coordinatorHostname = osHostname();
                     const selectedCoordinatorNodeId = readStringValue(
                         mesh.coordinator?.preferredNodeId,
-                        (mesh.nodes?.[0] as any)?.id,
-                        (mesh.nodes?.[0] as any)?.nodeId,
+                        normalizeMeshNodeId(mesh.nodes?.[0] as any),
                     );
                     const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes)
                         ? selectedCoordinatorNodeId
@@ -8183,7 +8394,7 @@ export class DaemonCommandRouter {
                     const refreshedAt = new Date().toISOString();
                     const nodeStatuses = [];
                     for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
-                        const nodeId = String(node.id || node.nodeId || '');
+                        const nodeId = normalizeMeshNodeId(node) ?? '';
                         const daemonId = readStringValue(node.daemonId);
                         const nodeMachineId = readMeshNodeMachineId(node as Record<string, unknown>);
                         const nodeHostname = readMeshNodeHostname(node as Record<string, unknown>);
@@ -8445,7 +8656,7 @@ export class DaemonCommandRouter {
                         liveSessionRecords: liveMeshSessions,
                     });
                     const { getMeshStatusMissionSummaries } = await import('../mesh/mesh-missions.js');
-                    const missions = getMeshStatusMissionSummaries(meshId);
+                    const missions = getMeshStatusMissionSummaries(meshId, { verbose: verboseMissions });
                     const statusResult = {
                         success: true,
                         meshId: mesh.id,
@@ -8505,7 +8716,12 @@ export class DaemonCommandRouter {
                             })),
                     };
                     const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult as any;
-                    const rememberedStatus = this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
+                    // Verbose carries full mission goals; never store it in the shared
+                    // (compact) aggregate cache or a later compact poll would return the
+                    // heavy goals from cache. Return it without caching.
+                    const rememberedStatus = verboseMissions
+                        ? cacheableStatusResult
+                        : this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
                     const returnedStatus = {
                         ...rememberedStatus,
                         ...(pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}),