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

package/dist/index.js

@@ -29983,10 +29983,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "396cb9c4084ea658cd3606b76948987cd875f138" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "396cb9c4" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.291" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-16T06:43:03.621Z" : void 0);
+      const commit = readInjected(true ? "88f97abcc85d83fe5d5313b229d32a7d76b1208a" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "88f97abc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.293" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-16T11:14:20.929Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -30055,6 +30055,15 @@ var require_dist3 = __commonJS({
         );
       }
     }
+    function isNonRuntimeRootFile(file2) {
+      const base = file2.slice(file2.lastIndexOf("/") + 1);
+      if (/^\.(?:verify|marker|converge|ff-verify|patch-equiv|live-verify)\b/i.test(base)) return true;
+      if (/(?:^|\/)docs\//i.test(file2)) return true;
+      if (/^(?:README|CHANGELOG|LICENSE|NOTICE|AUTHORS|CONTRIBUTING|CODEOWNERS)(?:\.[A-Za-z0-9]+)?$/i.test(base)) {
+        return true;
+      }
+      return false;
+    }
     async function classifyDaemonBuildChange(repoPath, buildCommit, options) {
       try {
         const diff = await runGit(repoPath, ["diff", "--name-only", `${buildCommit}..HEAD`], options);
@@ -30063,18 +30072,18 @@ var require_dist3 = __commonJS({
           return { isDaemonAffecting: true, affectedPackages: [] };
         }
         const pkgs = /* @__PURE__ */ new Set();
-        let sawNonPackageOrUnknown = false;
+        let sawRuntimeAmbiguousNonPackage = false;
         for (const file2 of files) {
           const match = file2.match(/(?:^|\/)packages\/([^/]+)\//);
           if (!match) {
-            sawNonPackageOrUnknown = true;
+            if (!isNonRuntimeRootFile(file2)) sawRuntimeAmbiguousNonPackage = true;
             continue;
           }
           pkgs.add(match[1]);
         }
         const affectedPackages = [...pkgs].sort();
-        const allWebOnly = !sawNonPackageOrUnknown && affectedPackages.length > 0 && affectedPackages.every((p) => WEB_ONLY_PACKAGES.has(p) && !DAEMON_RUNTIME_PACKAGES.has(p));
-        return { isDaemonAffecting: !allWebOnly, affectedPackages };
+        const allBenign = !sawRuntimeAmbiguousNonPackage && affectedPackages.every((p) => WEB_ONLY_PACKAGES.has(p) && !DAEMON_RUNTIME_PACKAGES.has(p));
+        return { isDaemonAffecting: !allBenign, affectedPackages };
       } catch {
         return { isDaemonAffecting: true, affectedPackages: [] };
       }
@@ -30101,7 +30110,8 @@ var require_dist3 = __commonJS({
             options
           );
           const scopeLabel = scope === "root" ? "workspace" : scope;
-          const warning = isDaemonAffecting ? `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}. Merged code is NOT live until the daemon is rebuilt/redeployed and restarted \u2014 a local dist rebuild alone does not update a cloud daemon.` : `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}, but only web packages changed (${(affectedPackages || []).join(", ") || "web"}). Daemon restart NOT required \u2014 redeploy the web app to reflect the change.`;
+          const benignDetail = affectedPackages.length > 0 ? `only web packages changed (${affectedPackages.join(", ")})` : "only non-runtime files changed (markers/docs)";
+          const warning = isDaemonAffecting ? `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}. Merged code is NOT live until the daemon is rebuilt/redeployed and restarted \u2014 a local dist rebuild alone does not update a cloud daemon.` : `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}, but ${benignDetail}. Daemon restart NOT required \u2014 redeploy the web app to reflect the change.`;
           return {
             buildCommit: build.commit,
             buildCommitShort: build.commitShort,
@@ -31713,7 +31723,7 @@ ${rules.join("\n")}`;
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start fresh only for independent work, provider mismatch, transcript contamination, or required worktree isolation.
 - **Respect explicit provider requests.** Map: Hermes \u2192 \`hermes-cli\`, Claude/Claude Code \u2192 \`claude-cli\`, Codex \u2192 \`codex-cli\`, Gemini \u2192 \`gemini-cli\`, Antigravity \u2192 \`antigravity-cli\`. Never substitute the coordinator's own runtime.
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
-- **Limit parallelism.** Start with 1\u20132 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing.
+- **Limit parallelism.** Start with 1\u20132 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load \u2014 it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.
@@ -31772,7 +31782,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
    c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
    d. For the first dispatch of a new task, provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
-4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`.
+4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`. **Proactively parallelize new work.** When the user reports a new bug or asks for new work, start it immediately if it is independent of in-flight tasks and there is headroom under \`maxParallelTasks\` \u2014 do not wait for a current task to finish or for the user to prompt you to parallelize. Read-only diagnosis (\`live_debug_readonly\`) has no isolation or merge cost, so dispatch it in parallel right away. The no-polling / concurrency-limit rules constrain *re-checking or duplicating already-dispatched work*; they are **not** a reason to defer starting a new, independent task.
 5. **Verify** \u2014 When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
 7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
@@ -34138,11 +34148,40 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
             ).get(meshId);
             return row?.cnt ?? 0;
           }
+          /**
+           * Mark specific pending-event rows drained by id (ack). Used by the
+           * unresolved-delegate durable-forward outbox: an event is peeked (not drained)
+           * while its push to the coordinator is unconfirmed, then marked drained ONLY
+           * after the push is acked. A failed push leaves the row undrained so the next
+           * reconcile tick retries it. Returns the number of rows newly marked drained.
+           */
+          markPendingEventsDrainedById(ids) {
+            const idList = ids.filter((id) => typeof id === "string" && id.length > 0);
+            if (idList.length === 0) return 0;
+            const now = Date.now();
+            return this.db.prepare(
+              `UPDATE mesh_pending_events SET drained = 1, drained_at = ? WHERE drained = 0 AND id IN (${idList.map(() => "?").join(",")})`
+            ).run(now, ...idList).changes;
+          }
+          /**
+           * Hard-delete pending-event rows by id (including the dedup fingerprint history).
+           * Used to expire an unresolved-delegate outbox entry that has exhausted its retry
+           * budget — fully removing it frees the fingerprint so a genuinely new completion
+           * for the same task could be re-queued later. Returns the number of rows deleted.
+           */
+          deletePendingEventsById(ids) {
+            const idList = ids.filter((id) => typeof id === "string" && id.length > 0);
+            if (idList.length === 0) return 0;
+            return this.db.prepare(
+              `DELETE FROM mesh_pending_events WHERE id IN (${idList.map(() => "?").join(",")})`
+            ).run(...idList).changes;
+          }
         };
       }
     });
     var mesh_missions_exports = {};
     __export2(mesh_missions_exports, {
+      GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
       MESH_MISSION_STATUSES: () => MESH_MISSION_STATUSES,
       buildMissionPromptSection: () => buildMissionPromptSection,
       getActiveMeshMissionSummaries: () => getActiveMeshMissionSummaries,
@@ -34214,12 +34253,23 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     function getActiveMeshMissionSummaries(meshId) {
       return getMeshMissions(meshId, ["active"]).map((mission) => summarizeMeshMission(meshId, mission));
     }
+    function slimMissionSummary(summary) {
+      const goal = typeof summary.goal === "string" ? summary.goal : "";
+      const goalTruncated = goal.length > GOAL_PREVIEW_MAX;
+      const { goal: _omitGoal, ...rest } = summary;
+      return {
+        ...rest,
+        goalPreview: goalTruncated ? goal.slice(0, GOAL_PREVIEW_MAX) : goal,
+        goalTruncated
+      };
+    }
     function getMeshStatusMissionSummaries(meshId, options) {
       const historyLimit = Math.max(0, options?.historyLimit ?? 10);
       const all = getMeshMissions(meshId);
       const live = all.filter((m) => m.status === "active" || m.status === "paused");
       const history = all.filter((m) => m.status === "completed" || m.status === "abandoned").sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || "")).slice(0, historyLimit);
-      return [...live, ...history].map((mission) => summarizeMeshMission(meshId, mission));
+      const full = [...live, ...history].map((mission) => summarizeMeshMission(meshId, mission));
+      return options?.verbose ? full : full.map(slimMissionSummary);
     }
     function buildMissionPromptSection(meshId) {
       const summaries = getActiveMeshMissionSummaries(meshId);
@@ -34241,6 +34291,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     var import_crypto6;
     var MESH_MISSION_STATUSES;
+    var GOAL_PREVIEW_MAX;
     var init_mesh_missions = __esm2({
       "src/mesh/mesh-missions.ts"() {
         "use strict";
@@ -34248,6 +34299,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         init_mesh_runtime_store();
         init_mesh_work_queue();
         MESH_MISSION_STATUSES = ["active", "paused", "completed", "abandoned"];
+        GOAL_PREVIEW_MAX = 120;
       }
     });
     function readString3(value) {
@@ -35944,10 +35996,222 @@ ${rendered}`, "utf-8");
         STATUS_OPTIONS = { refreshUpstream: true, includeSubmodules: true, timeoutMs: 15e3 };
       }
     });
+    function readRecord3(value) {
+      return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    }
+    function readString5(...values) {
+      for (const value of values) {
+        if (typeof value !== "string") continue;
+        const trimmed = value.trim();
+        if (trimmed) return trimmed;
+      }
+      return void 0;
+    }
+    function readNumber(...values) {
+      for (const value of values) {
+        if (typeof value === "number" && Number.isFinite(value)) return value;
+      }
+      return void 0;
+    }
+    function readBoolean(...values) {
+      for (const value of values) {
+        if (typeof value === "boolean") return value;
+      }
+      return void 0;
+    }
+    function joinRepoPath(root, relativePath) {
+      const normalizedRoot = typeof root === "string" ? root.trim().replace(/[\\/]+$/, "") : "";
+      const normalizedPath = typeof relativePath === "string" ? relativePath.trim() : "";
+      if (!normalizedPath) return void 0;
+      if (/^(?:[A-Za-z]:[\\/]|\/)/.test(normalizedPath)) return normalizedPath;
+      if (!normalizedRoot) return void 0;
+      return `${normalizedRoot}/${normalizedPath.replace(/^[\\/]+/, "")}`;
+    }
+    function scoreGitUpstreamFreshness(status) {
+      switch (status) {
+        case "fresh":
+          return 30;
+        case "no_upstream":
+          return 4;
+        case "unchecked":
+        case void 0:
+          return 0;
+        case "stale":
+          return -10;
+        case "unavailable":
+          return -15;
+        default:
+          return 0;
+      }
+    }
+    function readGitSubmodules(value, parentRepoRoot) {
+      if (!Array.isArray(value)) return void 0;
+      const submodules = value.map((entry) => {
+        const submodule = readRecord3(entry);
+        const path40 = readString5(submodule.path);
+        const commit = readString5(submodule.commit);
+        const repoPath = readString5(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path40);
+        if (!path40 || !commit) return null;
+        const result = {
+          path: path40,
+          commit,
+          dirty: readBoolean(submodule.dirty) ?? false,
+          outOfSync: readBoolean(submodule.outOfSync, submodule.out_of_sync) ?? false,
+          lastCheckedAt: readNumber(submodule.lastCheckedAt, submodule.last_checked_at) ?? Date.now()
+        };
+        if (repoPath) result.repoPath = repoPath;
+        const error48 = readString5(submodule.error);
+        if (error48) result.error = error48;
+        return result;
+      }).filter((entry) => entry !== null);
+      return submodules.length > 0 ? submodules : void 0;
+    }
+    function hasGitStatusEvidence(status) {
+      return readBoolean(status.isGitRepo) !== void 0 || Boolean(readString5(status.branch, status.upstream, status.upstreamStatus, status.upstream_status, status.headCommit)) || Boolean(readString5(status.repoRoot, status.repo_root, status.workspace)) || readNumber(
+        status.ahead,
+        status.behind,
+        status.staged,
+        status.modified,
+        status.untracked,
+        status.deleted,
+        status.renamed,
+        status.lastCheckedAt,
+        status.last_checked_at
+      ) !== void 0 || Array.isArray(status.submodules) && status.submodules.length > 0;
+    }
+    function normalizeGitStatus(status, node, options) {
+      const explicitIsGitRepo = readBoolean(status.isGitRepo);
+      if (!Object.keys(status).length || !hasGitStatusEvidence(status)) return void 0;
+      const isGitRepo = explicitIsGitRepo ?? true;
+      const conflictFiles = Array.isArray(status.conflictFiles) ? status.conflictFiles.filter((entry) => typeof entry === "string") : [];
+      const conflictCount = readNumber(status.conflicts) ?? conflictFiles.length;
+      const hasConflicts = readBoolean(status.hasConflicts) ?? conflictCount > 0;
+      const repoRoot = readString5(status.repoRoot, status.repo_root, node.repoRoot, node.repo_root, status.workspace, node.workspace) || void 0;
+      const submodules = readGitSubmodules(status.submodules, repoRoot);
+      const upstreamStatus = readString5(status.upstreamStatus, status.upstream_status);
+      const upstreamFetchedAt = readNumber(status.upstreamFetchedAt, status.upstream_fetched_at);
+      const upstreamFetchError = readString5(status.upstreamFetchError, status.upstream_fetch_error);
+      const error48 = readString5(status.error);
+      const staged = readNumber(status.staged) ?? 0;
+      const modified = readNumber(status.modified) ?? 0;
+      const untracked = readNumber(status.untracked) ?? 0;
+      const deleted = readNumber(status.deleted) ?? 0;
+      const renamed = readNumber(status.renamed) ?? 0;
+      return {
+        workspace: readString5(status.workspace, node.workspace) || "",
+        repoRoot: repoRoot ?? null,
+        isGitRepo,
+        branch: readString5(status.branch) ?? null,
+        headCommit: readString5(status.headCommit) ?? null,
+        headMessage: readString5(status.headMessage) ?? null,
+        upstream: readString5(status.upstream) ?? null,
+        upstreamStatus: upstreamStatus ?? "unchecked",
+        ...upstreamFetchedAt !== void 0 ? { upstreamFetchedAt } : {},
+        ...upstreamFetchError ? { upstreamFetchError } : {},
+        ahead: readNumber(status.ahead) ?? 0,
+        behind: readNumber(status.behind) ?? 0,
+        staged,
+        modified,
+        untracked,
+        deleted,
+        renamed,
+        dirty: readBoolean(status.dirty, status.isDirty, status.is_dirty) ?? (staged + modified + untracked + deleted + renamed > 0 || hasConflicts),
+        hasConflicts,
+        conflictFiles,
+        stashCount: readNumber(status.stashCount, status.stash_count) ?? 0,
+        lastCheckedAt: options?.lastCheckedAt ?? readNumber(status.lastCheckedAt, status.last_checked_at) ?? Date.now(),
+        ...submodules ? { submodules } : {},
+        ...error48 ? { error: error48 } : {}
+      };
+    }
+    function scoreGitStatusCandidate(git) {
+      if (!git) return Number.NEGATIVE_INFINITY;
+      let score = 0;
+      if (git.isGitRepo === true) score += 50;
+      if (git.isGitRepo === false) score -= 10;
+      if (git.branch) score += 20;
+      if (git.headCommit) score += 20;
+      if (git.upstream) score += 10;
+      score += scoreGitUpstreamFreshness(git.upstreamStatus);
+      if (typeof git.ahead === "number") score += 2;
+      if (typeof git.behind === "number") score += 2;
+      if (Array.isArray(git.submodules) && git.submodules.length > 0) score += 4 + git.submodules.length;
+      if (git.error) score -= 20;
+      return score;
+    }
+    function pickBestTransitGitStatus(node, options) {
+      const rawGit = readRecord3(node.lastGit ?? node.last_git);
+      const gitResult = readRecord3(rawGit.result);
+      const directStatus = readRecord3(rawGit.status);
+      const nestedStatus = readRecord3(gitResult.status);
+      const rawProbe = readRecord3(node.lastProbe ?? node.last_probe);
+      const probeGit = readRecord3(rawProbe.git);
+      const probeGitResult = readRecord3(probeGit.result);
+      const probeDirectStatus = readRecord3(probeGit.status);
+      const probeNestedStatus = readRecord3(probeGitResult.status);
+      const lastCheckedAt = options?.lastCheckedAt;
+      let best = null;
+      for (const status of [directStatus, nestedStatus, probeDirectStatus, probeNestedStatus]) {
+        const normalized = normalizeGitStatus(status, node, { lastCheckedAt: lastCheckedAt ?? Date.now() });
+        if (!normalized) continue;
+        const score = scoreGitStatusCandidate(normalized);
+        if (!best || score > best.score) best = { git: normalized, score };
+      }
+      return best?.git;
+    }
+    function normalizeMeshNodeId(node) {
+      const record2 = node && typeof node === "object" ? node : {};
+      return readString5(record2.id, record2.nodeId, record2.node_id);
+    }
+    function meshNodeIdMatches(node, candidateId) {
+      if (!candidateId) return false;
+      const trimmed = candidateId.trim();
+      if (!trimmed) return false;
+      return normalizeMeshNodeId(node) === trimmed;
+    }
+    function summarizeGitShape(status) {
+      const record2 = readRecord3(status);
+      if (!Object.keys(record2).length) return null;
+      const submodules = Array.isArray(record2.submodules) ? record2.submodules.map((entry) => {
+        const sub = readRecord3(entry);
+        return {
+          path: readString5(sub.path) ?? null,
+          commit: readString5(sub.commit)?.slice(0, 12) ?? null,
+          dirty: readBoolean(sub.dirty) ?? false,
+          outOfSync: readBoolean(sub.outOfSync, sub.out_of_sync) ?? false
+        };
+      }) : [];
+      return {
+        isGitRepo: readBoolean(record2.isGitRepo),
+        workspace: readString5(record2.workspace) ?? null,
+        repoRoot: readString5(record2.repoRoot, record2.repo_root) ?? null,
+        branch: readString5(record2.branch) ?? null,
+        upstream: readString5(record2.upstream) ?? null,
+        upstreamStatus: readString5(record2.upstreamStatus, record2.upstream_status) ?? null,
+        headCommit: readString5(record2.headCommit, record2.head_commit)?.slice(0, 12) ?? null,
+        ahead: readNumber(record2.ahead) ?? null,
+        behind: readNumber(record2.behind) ?? null,
+        dirtyCounts: {
+          staged: readNumber(record2.staged) ?? 0,
+          modified: readNumber(record2.modified) ?? 0,
+          untracked: readNumber(record2.untracked) ?? 0,
+          deleted: readNumber(record2.deleted) ?? 0,
+          renamed: readNumber(record2.renamed) ?? 0
+        },
+        lastCheckedAt: readNumber(record2.lastCheckedAt, record2.last_checked_at) ?? null,
+        submoduleCount: submodules.length,
+        submodules
+      };
+    }
+    var init_dist = __esm2({
+      "../mesh-shared/dist/index.mjs"() {
+        "use strict";
+      }
+    });
     function readNonEmptyString2(value) {
       return typeof value === "string" && value.trim() ? value.trim() : "";
     }
-    function readRecord3(value) {
+    function readRecord4(value) {
       return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
     }
     function buildMeshWorkerRelayStamp(currentSettings, meshContext) {
@@ -35971,13 +36235,13 @@ ${rendered}`, "utf-8");
       return readNonEmptyString2(event.targetSessionId) || readNonEmptyString2(event.sessionId) || readNonEmptyString2(event.instanceId) || readNonEmptyString2(fallback);
     }
     function readRefineJobId(event) {
-      const metadata = readRecord3(event.metadataEvent) || event;
-      const result = readRecord3(metadata.result);
-      const refineJob = readRecord3(result?.refineJob);
+      const metadata = readRecord4(event.metadataEvent) || event;
+      const result = readRecord4(metadata.result);
+      const refineJob = readRecord4(result?.refineJob);
       return readNonEmptyString2(metadata.jobId) || readNonEmptyString2(refineJob?.jobId);
     }
     function readWorkerResultMetadata(event) {
-      return readRecord3(event.workerResult) || readRecord3(event.meshWorkerResult) || readRecord3(event.structuredResult);
+      return readRecord4(event.workerResult) || readRecord4(event.meshWorkerResult) || readRecord4(event.structuredResult);
     }
     function formatCompletionMetadata(event) {
       const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === "object" ? event.completionDiagnostic : null;
@@ -36055,10 +36319,10 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
       }
       if (args.event === "refine:completed") {
         const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
-        const result = readRecord3(args.metadataEvent.result);
-        const validationSummary = readRecord3(result?.validationSummary);
-        const patchEquivalence = readRecord3(result?.patchEquivalence);
-        const finalConvergence = readRecord3(result?.finalBranchConvergenceState);
+        const result = readRecord4(args.metadataEvent.result);
+        const validationSummary = readRecord4(result?.validationSummary);
+        const patchEquivalence = readRecord4(result?.patchEquivalence);
+        const finalConvergence = readRecord4(result?.finalBranchConvergenceState);
         const validationStatus = readNonEmptyString2(validationSummary?.status);
         const patchStatus = readNonEmptyString2(patchEquivalence?.status) || (patchEquivalence?.equivalent === true ? "passed" : "");
         const into = readNonEmptyString2(result?.into);
@@ -36079,10 +36343,10 @@ Next step: ${nextStep}`;
       }
       if (args.event === "refine:failed") {
         const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
-        const result = readRecord3(args.metadataEvent.result);
-        const validationSummary = readRecord3(result?.validationSummary);
-        const patchEquivalence = readRecord3(result?.patchEquivalence);
-        const finalConvergence = readRecord3(result?.finalBranchConvergenceState);
+        const result = readRecord4(args.metadataEvent.result);
+        const validationSummary = readRecord4(result?.validationSummary);
+        const patchEquivalence = readRecord4(result?.patchEquivalence);
+        const finalConvergence = readRecord4(result?.finalBranchConvergenceState);
         const code = readNonEmptyString2(result?.code);
         const error48 = readNonEmptyString2(result?.error);
         const validationStatus = readNonEmptyString2(validationSummary?.status);
@@ -36127,9 +36391,9 @@ Next step: ${nextStep}`;
       return out;
     }
     function readRefineJobId2(event) {
-      const metadata = readRecord3(event.metadataEvent) || event;
-      const result = readRecord3(metadata.result);
-      const refineJob = readRecord3(result?.refineJob);
+      const metadata = readRecord4(event.metadataEvent) || event;
+      const result = readRecord4(metadata.result);
+      const refineJob = readRecord4(result?.refineJob);
       return readNonEmptyString2(metadata.jobId) || readNonEmptyString2(refineJob?.jobId);
     }
     function hasPendingRefineTerminalEventDuplicate(event) {
@@ -36141,13 +36405,13 @@ Next step: ${nextStep}`;
       );
     }
     function buildPendingEventFingerprint(event) {
-      const metadata = readRecord3(event.metadataEvent) || {};
+      const metadata = readRecord4(event.metadataEvent) || {};
       if (event.event === "worktree_bootstrap_complete" || event.event === "worktree_bootstrap_failed") {
         return [event.meshId, event.event, event.nodeId || ""].join("::");
       }
       const sessionId = resolveEventSessionId(metadata);
       const providerSessionId = readNonEmptyString2(metadata.providerSessionId);
-      const taskId = readNonEmptyString2(metadata.taskId) || readNonEmptyString2(readRecord3(metadata.payload)?.taskId);
+      const taskId = readNonEmptyString2(metadata.taskId) || readNonEmptyString2(readRecord4(metadata.payload)?.taskId);
       const jobId = readRefineJobId2(event);
       const timestamp = metadata.timestamp !== void 0 && metadata.timestamp !== null ? String(metadata.timestamp) : "";
       return [
@@ -36215,15 +36479,15 @@ Next step: ${nextStep}`;
       for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
         if (entry.kind !== "task_completed" && entry.kind !== "task_failed") continue;
-        const payload = readRecord3(entry.payload);
+        const payload = readRecord4(entry.payload);
         if (payload?.source !== "refine_mesh_node_async_job") continue;
-        const refineJob = readRecord3(payload.refineJob);
+        const refineJob = readRecord4(payload.refineJob);
         const jobId = readNonEmptyString2(refineJob?.jobId);
         if (!jobId || !acceptedJobIds.has(jobId)) continue;
         const eventName = entry.kind === "task_completed" ? "refine:completed" : "refine:failed";
         if (existingTerminalJobIds.has(`${eventName}:${jobId}`)) continue;
         existingTerminalJobIds.add(`${eventName}:${jobId}`);
-        const result = readRecord3(payload.result);
+        const result = readRecord4(payload.result);
         const metadataEvent = {
           source: "refine_mesh_node_async_job",
           jobId,
@@ -36835,7 +37099,7 @@ Next step: ${nextStep}`;
       const providerType = readNonEmptyString2(args.metadataEvent.providerType);
       const providerSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId);
       const workerResult = readWorkerResultMetadata(args.metadataEvent);
-      const completionDiagnostic = readRecord3(args.metadataEvent.completionDiagnostic);
+      const completionDiagnostic = readRecord4(args.metadataEvent.completionDiagnostic);
       const finalSummary = readNonEmptyString2(args.metadataEvent.finalSummary);
       const status = readNonEmptyString2(args.metadataEvent.status).toLowerCase();
       const explicitCompletionEvidence = Boolean(
@@ -37151,6 +37415,111 @@ Next step: ${nextStep}`;
         recentUnroutableDiagnostics = /* @__PURE__ */ new Map();
       }
     });
+    function getStore() {
+      try {
+        return MeshRuntimeStore.getInstance();
+      } catch {
+        return void 0;
+      }
+    }
+    function enqueueUnresolvedDelegateForward(coordinatorDaemonId, eventName, forwardPayload) {
+      const target = readNonEmptyString2(coordinatorDaemonId);
+      const event = readNonEmptyString2(eventName);
+      if (!target || !event) return false;
+      const store = getStore();
+      if (!store) return false;
+      const queuedAt = Date.now();
+      const fingerprintSource = {
+        event,
+        meshId: UNRESOLVED_FORWARD_OUTBOX_MESH_ID,
+        nodeLabel: readNonEmptyString2(forwardPayload.nodeId) || readNonEmptyString2(forwardPayload.workspace) || "unresolved-delegate",
+        nodeId: readNonEmptyString2(forwardPayload.nodeId) || void 0,
+        workspace: readNonEmptyString2(forwardPayload.workspace) || void 0,
+        metadataEvent: forwardPayload,
+        queuedAt,
+        targetCoordinatorDaemonId: target
+      };
+      const fingerprint = `${target}::${buildPendingEventFingerprint(fingerprintSource)}`;
+      try {
+        const inserted = store.insertPendingEvent({
+          id: (0, import_crypto9.randomUUID)(),
+          meshId: UNRESOLVED_FORWARD_OUTBOX_MESH_ID,
+          coordinatorDaemonId: target,
+          event,
+          // Store the flat forward payload + the queue timestamp so the retry tick can
+          // rebuild the push args and apply age-based expiry without a schema change.
+          payload: { forwardPayload, coordinatorDaemonId: target, queuedAt },
+          fingerprint,
+          queuedAt
+        });
+        if (inserted) {
+          LOG2.info("MeshEvents", `Durably queued unresolved-delegate ${event} for coordinator ${target} (outbox)`);
+        }
+        return true;
+      } catch (e) {
+        LOG2.warn("MeshEvents", `Failed to persist unresolved-delegate forward to outbox: ${e?.message || e}`);
+        return false;
+      }
+    }
+    function peekUnresolvedDelegateForwards() {
+      const store = getStore();
+      if (!store) return [];
+      let rows;
+      try {
+        rows = store.peekPendingEvents(UNRESOLVED_FORWARD_OUTBOX_MESH_ID);
+      } catch {
+        return [];
+      }
+      const out = [];
+      for (const row of rows) {
+        const stored = row.payload && typeof row.payload === "object" ? row.payload : {};
+        const coordinatorDaemonId = readNonEmptyString2(stored.coordinatorDaemonId);
+        const forwardPayload = stored.forwardPayload && typeof stored.forwardPayload === "object" ? stored.forwardPayload : void 0;
+        if (!coordinatorDaemonId || !forwardPayload) continue;
+        const queuedAt = typeof stored.queuedAt === "number" ? stored.queuedAt : 0;
+        out.push({ id: row.id, coordinatorDaemonId, payload: forwardPayload, queuedAt });
+      }
+      return out;
+    }
+    function ackUnresolvedDelegateForward(id) {
+      const store = getStore();
+      if (!store) return;
+      try {
+        store.markPendingEventsDrainedById([id]);
+      } catch {
+      }
+    }
+    function expireStaleUnresolvedDelegateForwards(nowMs = Date.now()) {
+      const entries = peekUnresolvedDelegateForwards();
+      const staleIds = entries.filter((e) => e.queuedAt > 0 && nowMs - e.queuedAt >= UNRESOLVED_FORWARD_MAX_AGE_MS).map((e) => e.id);
+      if (staleIds.length === 0) return 0;
+      const store = getStore();
+      if (!store) return 0;
+      try {
+        const removed = store.deletePendingEventsById(staleIds);
+        if (removed > 0) {
+          LOG2.warn("MeshEvents", `Expired ${removed} unresolved-delegate forward(s) after ${Math.round(UNRESOLVED_FORWARD_MAX_AGE_MS / 6e4)}m of failed retries \u2014 coordinator unreachable, completion dropped`);
+        }
+        return removed;
+      } catch {
+        return 0;
+      }
+    }
+    var import_crypto9;
+    var UNRESOLVED_FORWARD_OUTBOX_MESH_ID;
+    var UNRESOLVED_FORWARD_MAX_AGE_MS;
+    var init_mesh_unresolved_forward_outbox = __esm2({
+      "src/mesh/mesh-unresolved-forward-outbox.ts"() {
+        "use strict";
+        import_crypto9 = require("crypto");
+        init_logger();
+        init_mesh_runtime_store();
+        init_mesh_events_pending();
+        init_mesh_events_utils();
+        UNRESOLVED_FORWARD_OUTBOX_MESH_ID = "__unresolved_forward_outbox__";
+        UNRESOLVED_FORWARD_MAX_AGE_MS = 30 * 60 * 1e3;
+      }
+    });
     function resolveCoordinatorDrainDaemonIds(components) {
       const ids = /* @__PURE__ */ new Set();
       const statusInstanceId = readNonEmptyString2(components.statusInstanceId);
@@ -37554,7 +37923,7 @@ Next step: ${nextStep}`;
       return { reason: `provider_priority_unusable: ${failed.join("; ") || nodeId}` };
     }
     function readMeshNodeId(node) {
-      return readNonEmptyString2(node?.id) || readNonEmptyString2(node?.nodeId) || readNonEmptyString2(node?.node_id);
+      return normalizeMeshNodeId(node) ?? "";
     }
     async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       const queue = getQueue(meshId);
@@ -37783,7 +38152,7 @@ Next step: ${nextStep}`;
     }
     async function maybeAutoFastForwardIdleNode(components, args) {
       const mesh = getMeshWithCache(components, args.meshId);
-      const node = mesh?.nodes?.find((candidate) => candidate?.id === args.nodeId || candidate?.nodeId === args.nodeId);
+      const node = mesh?.nodes?.find((candidate) => meshNodeIdMatches(candidate, args.nodeId));
       const workspace = readNonEmptyString2(node?.workspace);
       if (!workspace) return;
       if (!(0, import_fs10.existsSync)(workspace)) return;
@@ -38284,12 +38653,25 @@ Next step: ${nextStep}`;
         nodeId: readNonEmptyString2(routing.nodeId) || readNonEmptyString2(event.meshNodeId) || void 0,
         workspace: readNonEmptyString2(routing.workspace) || readNonEmptyString2(event.workspace) || void 0
       };
-      Promise.resolve(components.dispatchMeshCommand(coordinatorDaemonId, "mesh_forward_event", payload)).catch((e) => {
-        LOG2.warn("MeshEvents", `Fallback forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e}`);
+      const persisted = enqueueUnresolvedDelegateForward(coordinatorDaemonId, eventName, payload);
+      Promise.resolve(components.dispatchMeshCommand(coordinatorDaemonId, "mesh_forward_event", payload)).then((result) => {
+        if (result && result.success === false) {
+          LOG2.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued for retry`);
+          return;
+        }
+        if (persisted) ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload);
+      }).catch((e) => {
+        LOG2.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued for retry`);
       });
-      LOG2.info("MeshEvents", `Fallback-forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
+      LOG2.info("MeshEvents", `Durably forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
       return true;
     }
+    function ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload) {
+      const match = peekUnresolvedDelegateForwards().find(
+        (entry) => entry.coordinatorDaemonId === coordinatorDaemonId && readNonEmptyString2(entry.payload.event) === eventName && readNonEmptyString2(entry.payload.targetSessionId || entry.payload.sessionId || entry.payload.instanceId) === readNonEmptyString2(payload.targetSessionId || payload.sessionId || payload.instanceId) && readNonEmptyString2(entry.payload.workspace) === readNonEmptyString2(payload.workspace)
+      );
+      if (match) ackUnresolvedDelegateForward(match.id);
+    }
     function setupMeshEventForwarding(components) {
       components.instanceManager.onEvent((event) => {
         if (event.event === "agent:ready" || event.event === "agent:generating_completed") {
@@ -38384,7 +38766,9 @@ Next step: ${nextStep}`;
         init_mesh_runtime_store();
         init_mesh_events_pending();
         init_mesh_routing();
+        init_mesh_unresolved_forward_outbox();
         init_repo_mesh_types();
+        init_dist();
         init_mesh_events_stale();
         init_mesh_events_utils();
         REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
@@ -38496,6 +38880,13 @@ Next step: ${nextStep}`;
           return void 0;
         }
       })();
+      if (dispatchMeshCommand) {
+        try {
+          await retryUnresolvedDelegateForwards(components);
+        } catch (e) {
+          LOG2.warn("MeshReconcile", `Unresolved-delegate forward retry failed: ${e?.message || e}`);
+        }
+      }
       if (dispatchMeshCommand) {
         for (const mesh of listMeshes()) {
           const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
@@ -38549,6 +38940,28 @@ Next step: ${nextStep}`;
         }
       }
     }
+    async function retryUnresolvedDelegateForwards(components) {
+      const dispatchMeshCommand = components.dispatchMeshCommand;
+      if (!dispatchMeshCommand) return;
+      expireStaleUnresolvedDelegateForwards();
+      const entries = peekUnresolvedDelegateForwards();
+      if (entries.length === 0) return;
+      for (const entry of entries) {
+        let result;
+        try {
+          result = await dispatchMeshCommand(entry.coordinatorDaemonId, "mesh_forward_event", entry.payload);
+        } catch (e) {
+          LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued`);
+          continue;
+        }
+        if (result && result.success === false) {
+          LOG2.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued`);
+          continue;
+        }
+        ackUnresolvedDelegateForward(entry.id);
+        LOG2.info("MeshReconcile", `Retried+delivered unresolved-delegate ${readNonEmptyString2(entry.payload.event)} to coordinator ${entry.coordinatorDaemonId}`);
+      }
+    }
     async function pullRemoteNodeQueues(components, mesh, localDaemonId, candidateDaemonIds) {
       const dispatchMeshCommand = components.dispatchMeshCommand;
       if (!dispatchMeshCommand) return;
@@ -38625,6 +39038,7 @@ Next step: ${nextStep}`;
         init_mesh_events_pending();
         init_mesh_runtime_store();
         init_mesh_events_coordinator();
+        init_mesh_unresolved_forward_outbox();
         init_mesh_events_utils();
         DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
       }
@@ -47252,9 +47666,10 @@ ${lastSnapshot}`;
       };
     }
     init_mesh_work_queue();
+    init_dist();
     var DIRECT_DISPATCH_VIA = /* @__PURE__ */ new Set(["p2p_direct", "local_direct", "mesh_send_task"]);
     var TERMINAL_LEDGER_KINDS = /* @__PURE__ */ new Set(["task_completed", "task_failed", "task_stalled"]);
-    function readString5(value) {
+    function readString6(value) {
       return typeof value === "string" && value.trim() ? value.trim() : void 0;
     }
     function summarizeMessage(message) {
@@ -47269,7 +47684,7 @@ ${lastSnapshot}`;
     function sessionStatusFromNodes(nodes, nodeId, sessionId) {
       if (!Array.isArray(nodes)) return {};
       if (!nodeId) return { staleReason: "direct task has no node id" };
-      const node = nodes.find((item) => readString5(item?.id) === nodeId || readString5(item?.nodeId) === nodeId || readString5(item?.node_id) === nodeId);
+      const node = nodes.find((item) => meshNodeIdMatches(item, nodeId));
       if (!node) return { staleReason: "direct task node is no longer in the live mesh" };
       if (!sessionId) return {};
       const candidates = [];
@@ -47293,12 +47708,12 @@ ${lastSnapshot}`;
       }
       const session = candidates.find((item) => {
         if (typeof item === "string") return item === sessionId;
-        const id = readString5(item?.id) || readString5(item?.sessionId) || readString5(item?.session_id) || readString5(item?.runtimeSessionId) || readString5(item?.instanceId);
+        const id = readString6(item?.id) || readString6(item?.sessionId) || readString6(item?.session_id) || readString6(item?.runtimeSessionId) || readString6(item?.instanceId);
         return id === sessionId;
       });
       if (!session) return { staleReason: "direct task session is not present in live session records" };
       if (typeof session === "string") return {};
-      const raw = `${readString5(session.status) || ""} ${readString5(session.lifecycle) || ""} ${readString5(session.state) || ""} ${readString5(session.activeChat?.status) || ""}`.toLowerCase();
+      const raw = `${readString6(session.status) || ""} ${readString6(session.lifecycle) || ""} ${readString6(session.state) || ""} ${readString6(session.activeChat?.status) || ""}`.toLowerCase();
       if (raw.includes("approval")) return { status: "awaiting_approval" };
       if (raw.includes("generating") || raw.includes("running") || raw.includes("busy")) return { status: "generating" };
       if (raw.includes("failed") || raw.includes("stopped") || raw.includes("terminated") || raw.includes("exited")) return { status: "failed" };
@@ -47309,14 +47724,14 @@ ${lastSnapshot}`;
       if (entry.kind !== "task_dispatched") return false;
       const payload = entry.payload || {};
       if (payload.source === "direct") return true;
-      const via = readString5(payload.via);
+      const via = readString6(payload.via);
       return Boolean(via && DIRECT_DISPATCH_VIA.has(via) && payload.source !== "queue");
     }
     function directDispatchTaskId(entry) {
-      return readString5(entry.payload?.taskId) || entry.id;
+      return readString6(entry.payload?.taskId) || entry.id;
     }
     function terminalMatchesDispatch(terminal, dispatch, taskId) {
-      const terminalTaskId = readString5(terminal.payload?.taskId);
+      const terminalTaskId = readString6(terminal.payload?.taskId);
       if (terminalTaskId && terminalTaskId === taskId) return true;
       if (terminalTaskId && terminalTaskId !== taskId) return false;
       if (dispatch.sessionId && terminal.sessionId === dispatch.sessionId) return true;
@@ -47439,7 +47854,7 @@ ${lastSnapshot}`;
           const isNoTransition = !terminalStatus && !live.status;
           const isIdleUnacknowledged = status === "idle";
           const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
-          const message = readString5(dispatch.payload?.message) || readString5(dispatch.payload?.summary) || "";
+          const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
           const { title, summary: summary2 } = summarizeMessage(message);
           const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
           const record2 = {
@@ -47448,11 +47863,11 @@ ${lastSnapshot}`;
             status,
             nodeId: dispatch.nodeId,
             sessionId: dispatch.sessionId,
-            providerType: dispatch.providerType || readString5(dispatch.payload?.providerType),
-            taskTitle: readString5(dispatch.payload?.taskTitle) || title,
-            taskSummary: readString5(dispatch.payload?.taskSummary) || summary2,
+            providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
+            taskTitle: readString6(dispatch.payload?.taskTitle) || title,
+            taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
             message,
-            taskMode: readString5(dispatch.payload?.taskMode),
+            taskMode: readString6(dispatch.payload?.taskMode),
             createdAt: dispatch.timestamp,
             updatedAt: terminal?.timestamp || dispatch.timestamp,
             dispatchedAt: dispatch.timestamp,
@@ -47487,7 +47902,7 @@ ${lastSnapshot}`;
           const isNoTransition = !terminalStatus && !live.status;
           const isIdleUnacknowledged = status === "idle";
           const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || dispatchedToIdleSession && isIdleUnacknowledged) ? "direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition" : void 0;
-          const message = readString5(dispatch.payload?.message) || readString5(dispatch.payload?.summary) || "";
+          const message = readString6(dispatch.payload?.message) || readString6(dispatch.payload?.summary) || "";
           const { title, summary: summary2 } = summarizeMessage(message);
           const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
           const record2 = {
@@ -47496,11 +47911,11 @@ ${lastSnapshot}`;
             status,
             nodeId: dispatch.nodeId,
             sessionId: dispatch.sessionId,
-            providerType: dispatch.providerType || readString5(dispatch.payload?.providerType),
-            taskTitle: readString5(dispatch.payload?.taskTitle) || title,
-            taskSummary: readString5(dispatch.payload?.taskSummary) || summary2,
+            providerType: dispatch.providerType || readString6(dispatch.payload?.providerType),
+            taskTitle: readString6(dispatch.payload?.taskTitle) || title,
+            taskSummary: readString6(dispatch.payload?.taskSummary) || summary2,
             message,
-            taskMode: readString5(dispatch.payload?.taskMode),
+            taskMode: readString6(dispatch.payload?.taskMode),
             createdAt: dispatch.timestamp,
             updatedAt: terminal?.timestamp || dispatch.timestamp,
             dispatchedAt: dispatch.timestamp,
@@ -51804,7 +52219,7 @@ ${cleanBody}`;
         this.runtimeMessages = [];
       }
       updateSettings(newSettings) {
-        this.settings = { ...newSettings };
+        this.settings = { ...this.settings, ...newSettings };
         this.monitor.updateConfig({
           approvalAlert: this.settings.approvalAlert !== false,
           longGeneratingAlert: this.settings.longGeneratingAlert !== false,
@@ -52461,7 +52876,7 @@ ${effect.notification.body || ""}`.trim();
         this.extensions.clear();
       }
       updateSettings(newSettings) {
-        this.settings = { ...newSettings };
+        this.settings = { ...this.settings, ...newSettings };
         this.monitor.updateConfig({
           approvalAlert: this.settings.approvalAlert !== false,
           longGeneratingAlert: this.settings.longGeneratingAlert !== false,
@@ -61931,22 +62346,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         };
       }
       updateSettings(newSettings) {
-        const runtimeMeshSettings = {};
-        for (const key of [
-          "meshNodeFor",
-          "meshNodeId",
-          "meshActiveTaskId",
-          "meshCoordinatorFor",
-          "meshCoordinatorDaemonId",
-          "meshCoordinatorNodeId",
-          "spawnedSessionVisibility",
-          "launchedByCoordinator"
-        ]) {
-          if (this.settings[key] !== void 0 && newSettings[key] === void 0) {
-            runtimeMeshSettings[key] = this.settings[key];
-          }
-        }
-        this.settings = { ...newSettings, ...runtimeMeshSettings };
+        this.settings = { ...this.settings, ...newSettings };
         this.adapter.updateRuntimeSettings?.(this.settings);
         this.monitor.updateConfig({
           approvalAlert: this.settings.approvalAlert !== false,
@@ -69237,203 +69637,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_config();
     init_cli_detector();
     init_git_status();
-    function readRecord5(value) {
-      return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-    }
-    function readString6(...values) {
-      for (const value of values) {
-        if (typeof value !== "string") continue;
-        const trimmed = value.trim();
-        if (trimmed) return trimmed;
-      }
-      return void 0;
-    }
-    function readNumber(...values) {
-      for (const value of values) {
-        if (typeof value === "number" && Number.isFinite(value)) return value;
-      }
-      return void 0;
-    }
-    function readBoolean(...values) {
-      for (const value of values) {
-        if (typeof value === "boolean") return value;
-      }
-      return void 0;
-    }
-    function joinRepoPath(root, relativePath) {
-      const normalizedRoot = typeof root === "string" ? root.trim().replace(/[\\/]+$/, "") : "";
-      const normalizedPath = typeof relativePath === "string" ? relativePath.trim() : "";
-      if (!normalizedPath) return void 0;
-      if (/^(?:[A-Za-z]:[\\/]|\/)/.test(normalizedPath)) return normalizedPath;
-      if (!normalizedRoot) return void 0;
-      return `${normalizedRoot}/${normalizedPath.replace(/^[\\/]+/, "")}`;
-    }
-    function scoreGitUpstreamFreshness(status) {
-      switch (status) {
-        case "fresh":
-          return 30;
-        case "no_upstream":
-          return 4;
-        case "unchecked":
-        case void 0:
-          return 0;
-        case "stale":
-          return -10;
-        case "unavailable":
-          return -15;
-        default:
-          return 0;
-      }
-    }
-    function readGitSubmodules(value, parentRepoRoot) {
-      if (!Array.isArray(value)) return void 0;
-      const submodules = value.map((entry) => {
-        const submodule = readRecord5(entry);
-        const path40 = readString6(submodule.path);
-        const commit = readString6(submodule.commit);
-        const repoPath = readString6(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path40);
-        if (!path40 || !commit) return null;
-        const result = {
-          path: path40,
-          commit,
-          dirty: readBoolean(submodule.dirty) ?? false,
-          outOfSync: readBoolean(submodule.outOfSync, submodule.out_of_sync) ?? false,
-          lastCheckedAt: readNumber(submodule.lastCheckedAt, submodule.last_checked_at) ?? Date.now()
-        };
-        if (repoPath) result.repoPath = repoPath;
-        const error48 = readString6(submodule.error);
-        if (error48) result.error = error48;
-        return result;
-      }).filter((entry) => entry !== null);
-      return submodules.length > 0 ? submodules : void 0;
-    }
-    function hasGitStatusEvidence(status) {
-      return readBoolean(status.isGitRepo) !== void 0 || Boolean(readString6(status.branch, status.upstream, status.upstreamStatus, status.upstream_status, status.headCommit)) || Boolean(readString6(status.repoRoot, status.repo_root, status.workspace)) || readNumber(
-        status.ahead,
-        status.behind,
-        status.staged,
-        status.modified,
-        status.untracked,
-        status.deleted,
-        status.renamed,
-        status.lastCheckedAt,
-        status.last_checked_at
-      ) !== void 0 || Array.isArray(status.submodules) && status.submodules.length > 0;
-    }
-    function normalizeGitStatus(status, node, options) {
-      const explicitIsGitRepo = readBoolean(status.isGitRepo);
-      if (!Object.keys(status).length || !hasGitStatusEvidence(status)) return void 0;
-      const isGitRepo = explicitIsGitRepo ?? true;
-      const conflictFiles = Array.isArray(status.conflictFiles) ? status.conflictFiles.filter((entry) => typeof entry === "string") : [];
-      const conflictCount = readNumber(status.conflicts) ?? conflictFiles.length;
-      const hasConflicts = readBoolean(status.hasConflicts) ?? conflictCount > 0;
-      const repoRoot = readString6(status.repoRoot, status.repo_root, node.repoRoot, node.repo_root, status.workspace, node.workspace) || void 0;
-      const submodules = readGitSubmodules(status.submodules, repoRoot);
-      const upstreamStatus = readString6(status.upstreamStatus, status.upstream_status);
-      const upstreamFetchedAt = readNumber(status.upstreamFetchedAt, status.upstream_fetched_at);
-      const upstreamFetchError = readString6(status.upstreamFetchError, status.upstream_fetch_error);
-      const error48 = readString6(status.error);
-      const staged = readNumber(status.staged) ?? 0;
-      const modified = readNumber(status.modified) ?? 0;
-      const untracked = readNumber(status.untracked) ?? 0;
-      const deleted = readNumber(status.deleted) ?? 0;
-      const renamed = readNumber(status.renamed) ?? 0;
-      return {
-        workspace: readString6(status.workspace, node.workspace) || "",
-        repoRoot: repoRoot ?? null,
-        isGitRepo,
-        branch: readString6(status.branch) ?? null,
-        headCommit: readString6(status.headCommit) ?? null,
-        headMessage: readString6(status.headMessage) ?? null,
-        upstream: readString6(status.upstream) ?? null,
-        upstreamStatus: upstreamStatus ?? "unchecked",
-        ...upstreamFetchedAt !== void 0 ? { upstreamFetchedAt } : {},
-        ...upstreamFetchError ? { upstreamFetchError } : {},
-        ahead: readNumber(status.ahead) ?? 0,
-        behind: readNumber(status.behind) ?? 0,
-        staged,
-        modified,
-        untracked,
-        deleted,
-        renamed,
-        dirty: readBoolean(status.dirty, status.isDirty, status.is_dirty) ?? (staged + modified + untracked + deleted + renamed > 0 || hasConflicts),
-        hasConflicts,
-        conflictFiles,
-        stashCount: readNumber(status.stashCount, status.stash_count) ?? 0,
-        lastCheckedAt: options?.lastCheckedAt ?? readNumber(status.lastCheckedAt, status.last_checked_at) ?? Date.now(),
-        ...submodules ? { submodules } : {},
-        ...error48 ? { error: error48 } : {}
-      };
-    }
-    function scoreGitStatusCandidate(git) {
-      if (!git) return Number.NEGATIVE_INFINITY;
-      let score = 0;
-      if (git.isGitRepo === true) score += 50;
-      if (git.isGitRepo === false) score -= 10;
-      if (git.branch) score += 20;
-      if (git.headCommit) score += 20;
-      if (git.upstream) score += 10;
-      score += scoreGitUpstreamFreshness(git.upstreamStatus);
-      if (typeof git.ahead === "number") score += 2;
-      if (typeof git.behind === "number") score += 2;
-      if (Array.isArray(git.submodules) && git.submodules.length > 0) score += 4 + git.submodules.length;
-      if (git.error) score -= 20;
-      return score;
-    }
-    function pickBestTransitGitStatus(node, options) {
-      const rawGit = readRecord5(node.lastGit ?? node.last_git);
-      const gitResult = readRecord5(rawGit.result);
-      const directStatus = readRecord5(rawGit.status);
-      const nestedStatus = readRecord5(gitResult.status);
-      const rawProbe = readRecord5(node.lastProbe ?? node.last_probe);
-      const probeGit = readRecord5(rawProbe.git);
-      const probeGitResult = readRecord5(probeGit.result);
-      const probeDirectStatus = readRecord5(probeGit.status);
-      const probeNestedStatus = readRecord5(probeGitResult.status);
-      const lastCheckedAt = options?.lastCheckedAt;
-      let best = null;
-      for (const status of [directStatus, nestedStatus, probeDirectStatus, probeNestedStatus]) {
-        const normalized = normalizeGitStatus(status, node, { lastCheckedAt: lastCheckedAt ?? Date.now() });
-        if (!normalized) continue;
-        const score = scoreGitStatusCandidate(normalized);
-        if (!best || score > best.score) best = { git: normalized, score };
-      }
-      return best?.git;
-    }
-    function summarizeGitShape(status) {
-      const record2 = readRecord5(status);
-      if (!Object.keys(record2).length) return null;
-      const submodules = Array.isArray(record2.submodules) ? record2.submodules.map((entry) => {
-        const sub = readRecord5(entry);
-        return {
-          path: readString6(sub.path) ?? null,
-          commit: readString6(sub.commit)?.slice(0, 12) ?? null,
-          dirty: readBoolean(sub.dirty) ?? false,
-          outOfSync: readBoolean(sub.outOfSync, sub.out_of_sync) ?? false
-        };
-      }) : [];
-      return {
-        isGitRepo: readBoolean(record2.isGitRepo),
-        workspace: readString6(record2.workspace) ?? null,
-        repoRoot: readString6(record2.repoRoot, record2.repo_root) ?? null,
-        branch: readString6(record2.branch) ?? null,
-        upstream: readString6(record2.upstream) ?? null,
-        upstreamStatus: readString6(record2.upstreamStatus, record2.upstream_status) ?? null,
-        headCommit: readString6(record2.headCommit, record2.head_commit)?.slice(0, 12) ?? null,
-        ahead: readNumber(record2.ahead) ?? null,
-        behind: readNumber(record2.behind) ?? null,
-        dirtyCounts: {
-          staged: readNumber(record2.staged) ?? 0,
-          modified: readNumber(record2.modified) ?? 0,
-          untracked: readNumber(record2.untracked) ?? 0,
-          deleted: readNumber(record2.deleted) ?? 0,
-          renamed: readNumber(record2.renamed) ?? 0
-        },
-        lastCheckedAt: readNumber(record2.lastCheckedAt, record2.last_checked_at) ?? null,
-        submoduleCount: submodules.length,
-        submodules
-      };
-    }
+    init_dist();
     init_logger();
     var fs222 = __toESM2(require("fs"));
     var path33 = __toESM2(require("path"));
@@ -70495,7 +70699,10 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         branchConvergenceSummary: status?.branchConvergenceSummary ?? status?.branch_convergence_summary ?? null,
         nodeCount: nodes.length,
         nodes: nodes.map((node) => ({
-          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,
@@ -70740,7 +70947,23 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       return inlineMesh.nodes.some((node) => hasInlineMeshTransientNodeState(node));
     }
     function readInlineMeshNodeId(node) {
-      return readStringValue(node?.id, node?.nodeId) || "";
+      return normalizeMeshNodeId(node) ?? "";
+    }
+    function foldMeshNodeIdentityToCanonical(node) {
+      if (!node || typeof node !== "object" || Array.isArray(node)) return node;
+      const canonical = normalizeMeshNodeId(node);
+      if (canonical === void 0) return node;
+      if (node.id === canonical && node.nodeId === canonical && node.node_id === void 0) return node;
+      node.id = canonical;
+      node.nodeId = canonical;
+      if ("node_id" in node) delete node.node_id;
+      return node;
+    }
+    function normalizeInlineMeshNodeIdentity(inlineMesh) {
+      if (!inlineMesh || typeof inlineMesh !== "object" || Array.isArray(inlineMesh)) return inlineMesh;
+      if (!Array.isArray(inlineMesh.nodes) || inlineMesh.nodes.length === 0) return inlineMesh;
+      for (const node of inlineMesh.nodes) foldMeshNodeIdentityToCanonical(node);
+      return inlineMesh;
     }
     function sanitizeInlineMesh(inlineMesh) {
       if (!inlineMesh || typeof inlineMesh !== "object" || Array.isArray(inlineMesh)) return inlineMesh;
@@ -70842,7 +71065,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       return "online";
     }
     function readMeshNodeLabel(status, node) {
-      return readStringValue(status.nodeId, node?.id, node?.nodeId) ?? "unknown";
+      return readStringValue(status.nodeId, normalizeMeshNodeId(node)) ?? "unknown";
     }
     function buildInlineMeshBranchConvergence(args) {
       const git = readObjectRecord(args.status.git);
@@ -71121,7 +71344,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       let peerConfirmedCount = 0;
       const unavailableNodeIds = [];
       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(
@@ -71252,7 +71475,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       const liveWorkspaces = /* @__PURE__ */ new Set();
       const missingLocalWorktreeNodeIds = /* @__PURE__ */ new Set();
       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);
@@ -71377,9 +71600,13 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
       return { enabled: false };
     }
-    async function computeGitPatchId(cwd, fromRef, toRef) {
+    async function computeGitPatchId(cwd, fromRef, toRef, excludePaths = []) {
       const { execFileSync: execFileSync6 } = await import("child_process");
-      const diff = execFileSync6("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
+      const diffArgs = ["diff", "--patch", "--full-index", fromRef, toRef];
+      if (excludePaths.length > 0) {
+        diffArgs.push("--", ".", ...excludePaths.map((path40) => `:(exclude)${path40}`));
+      }
+      const diff = execFileSync6("git", diffArgs, {
         cwd,
         encoding: "utf8",
         maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -71448,8 +71675,9 @@ ${mergeTreeErr?.stderr || ""}`;
             gitlinkTrivialFastForward
           };
         }
-        const expectedPatchId = await computeGitPatchId(repoRoot, mergeBase, branchHead);
-        const actualPatchId = await computeGitPatchId(repoRoot, baseHead, mergedTree);
+        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",
@@ -71645,6 +71873,14 @@ ${e?.stderr || ""}`
         return [];
       }
     }
+    function collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead) {
+      return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter((path40) => {
+        const baseCommit = readTreeObject(repoRoot, baseHead, path40);
+        const branchCommit = readTreeObject(repoRoot, branchHead, path40);
+        if (!baseCommit || !branchCommit) return false;
+        return isSubmoduleFastForward((0, import_path10.resolve)(repoRoot, path40), baseCommit, branchCommit);
+      });
+    }
     function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path40) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path40);
@@ -71694,20 +71930,95 @@ ${e?.stderr || ""}`
       }
       return { trivial: true, gitlinks: changedGitlinks };
     }
+    function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderCommit) {
+      try {
+        const tree = (0, import_node_child_process6.execFileSync)("git", ["rev-parse", `${commitish}^{tree}`], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: 1024 * 1024
+        }).trim();
+        if (!tree) return void 0;
+        const updates = paths.map((path40) => `160000 commit ${placeholderCommit}	${path40}`).join("\n");
+        if (!updates) return tree;
+        const tmpIndex = (0, import_path10.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+        const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
+        try {
+          (0, import_node_child_process6.execFileSync)("git", ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process6.execFileSync)("git", ["update-index", "--index-info"], {
+            cwd: repoRoot,
+            env: env2,
+            input: `${updates}
+`,
+            encoding: "utf8",
+            stdio: ["pipe", "ignore", "ignore"]
+          });
+          const newTree = (0, import_node_child_process6.execFileSync)("git", ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          return newTree || void 0;
+        } finally {
+          try {
+            fs24.rmSync(tmpIndex, { force: true });
+          } catch {
+          }
+        }
+      } catch {
+        return void 0;
+      }
+    }
     function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, gitlinks) {
       try {
-        const baseTree = (0, import_node_child_process6.execFileSync)("git", ["rev-parse", `${baseHead}^{tree}`], {
+        const branchGitlinks = gitlinks.filter((entry) => entry.branchCommit);
+        const gitlinkPaths = branchGitlinks.map((entry) => entry.path);
+        const mergeBase = (0, import_node_child_process6.execFileSync)("git", ["merge-base", baseHead, branchHead], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: 1024 * 1024
+        }).trim();
+        let mergedContentTree;
+        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 {
+              const baseEqCommit = (0, import_node_child_process6.execFileSync)("git", ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
+                cwd: repoRoot,
+                encoding: "utf8",
+                maxBuffer: 1024 * 1024
+              }).trim();
+              const oursEqCommit = (0, import_node_child_process6.execFileSync)("git", ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
+                cwd: repoRoot,
+                encoding: "utf8",
+                maxBuffer: 1024 * 1024
+              }).trim();
+              const theirsEqCommit = (0, import_node_child_process6.execFileSync)("git", ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
+                cwd: repoRoot,
+                encoding: "utf8",
+                maxBuffer: 1024 * 1024
+              }).trim();
+              const mergeOut = (0, import_node_child_process6.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] || void 0;
+            } catch {
+              mergedContentTree = void 0;
+            }
+          }
+        }
+        const contentTree = mergedContentTree || (0, import_node_child_process6.execFileSync)("git", ["rev-parse", `${baseHead}^{tree}`], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
         }).trim();
-        if (!baseTree) return void 0;
-        const updates = gitlinks.filter((entry) => entry.branchCommit).map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
-        if (!updates) return baseTree;
+        if (!contentTree) return void 0;
+        const updates = branchGitlinks.map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
+        if (!updates) return contentTree;
         const tmpIndex = (0, import_path10.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
-          (0, import_node_child_process6.execFileSync)("git", ["read-tree", baseTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process6.execFileSync)("git", ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
           (0, import_node_child_process6.execFileSync)("git", ["update-index", "--index-info"], {
             cwd: repoRoot,
             env: env2,
@@ -72367,7 +72678,7 @@ ${e?.stderr || ""}`
     function buildMemberJoinNode(mesh, args, fallbackDaemonId) {
       const requestedNodeId = typeof args?.memberNodeId === "string" ? args.memberNodeId.trim() : "";
       const explicit = args?.memberNode && typeof args.memberNode === "object" && !Array.isArray(args.memberNode) ? args.memberNode : null;
-      const configured = Array.isArray(mesh?.nodes) ? requestedNodeId ? mesh.nodes.find((node) => node?.id === requestedNodeId || node?.nodeId === requestedNodeId) : mesh.nodes[0] : null;
+      const configured = Array.isArray(mesh?.nodes) ? requestedNodeId ? mesh.nodes.find((node) => meshNodeIdMatches(node, requestedNodeId)) : mesh.nodes[0] : null;
       const source = explicit || configured;
       const workspace = typeof source?.workspace === "string" && source.workspace.trim() ? source.workspace.trim() : typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
       if (!workspace) return null;
@@ -72423,7 +72734,7 @@ ${e?.stderr || ""}`
           if (nodeId) unavailableNodeIds.add(nodeId);
         }
         const nodes = snapshot.nodes.map((statusNode) => {
-          const nodeId = readStringValue(statusNode?.nodeId, statusNode?.id);
+          const nodeId = normalizeMeshNodeId(statusNode);
           const inlineNode = nodeId ? inlineNodesById.get(nodeId) : void 0;
           if (!inlineNode) return statusNode;
           const liveGit = buildInlineMeshTransitGitStatus(inlineNode);
@@ -72536,7 +72847,7 @@ ${e?.stderr || ""}`
       }
       warmInlineMeshCache(meshId, inlineMesh) {
         if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
-        const sanitizedInlineMesh = sanitizeInlineMesh(inlineMesh);
+        const sanitizedInlineMesh = sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh));
         const cached22 = this.inlineMeshCache.get(meshId);
         if (cached22) {
           const merged = reconcileInlineMeshCache(cached22, sanitizedInlineMesh);
@@ -72553,7 +72864,7 @@ ${e?.stderr || ""}`
           if (cached3) {
             if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
               const merged = reconcileInlineMeshCache(cached3, inlineMesh);
-              this.inlineMeshCache.set(meshId, sanitizeInlineMesh(merged));
+              this.inlineMeshCache.set(meshId, sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(merged)));
               return { mesh: merged, inline: true, source: "inline_cache" };
             }
             return { mesh: cached3, inline: true, source: "inline_cache" };
@@ -72589,17 +72900,19 @@ ${e?.stderr || ""}`
         return null;
       }
       updateInlineMeshNode(meshId, mesh, node) {
-        if (!mesh || !Array.isArray(mesh.nodes) || !node?.id) return;
-        const idx = mesh.nodes.findIndex((entry) => 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) => meshNodeIdMatches(entry, incomingId));
         if (idx >= 0) mesh.nodes[idx] = node;
         else mesh.nodes.push(node);
         mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        for (const entry of mesh.nodes) foldMeshNodeIdentityToCanonical(entry);
         this.inlineMeshCache.set(meshId, mesh);
         this.invalidateAggregateMeshStatus(meshId);
       }
       removeInlineMeshNode(meshId, mesh, nodeId) {
         if (!mesh || !Array.isArray(mesh.nodes)) return false;
-        const idx = mesh.nodes.findIndex((entry) => entry?.id === nodeId || entry?.nodeId === nodeId);
+        const idx = mesh.nodes.findIndex((entry) => meshNodeIdMatches(entry, nodeId));
         if (idx === -1) return false;
         mesh.nodes.splice(idx, 1);
         mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -72630,7 +72943,7 @@ ${e?.stderr || ""}`
           };
         }
         const worktreeExists = fs24.existsSync(workspace);
-        const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => n.id === args.node.clonedFromNodeId || n.nodeId === args.node.clonedFromNodeId) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
+        const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
         const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
         if (!worktreeExists) {
           return { success: true, skipped: true, removedPath: workspace, repoRoot: repoRoot || void 0, reason: "worktree_path_missing" };
@@ -73273,12 +73586,12 @@ ${e?.stderr || ""}`
         try {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
-          const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+          const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
           if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh`, refineStages };
           if (!node.isLocalWorktree || !node.workspace) {
             return { success: false, error: `Refinery requires a local worktree node`, refineStages };
           }
-          const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : mesh?.nodes.find((n) => !n.isLocalWorktree);
+          const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => meshNodeIdMatches(n, node.clonedFromNodeId)) : mesh?.nodes.find((n) => !n.isLocalWorktree);
           const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
           if (!repoRoot) return { success: false, error: "Source node repoRoot not found", refineStages };
           const { execFile: execFile5 } = await import("child_process");
@@ -73913,7 +74226,7 @@ ${hintLines.join("\n")}` : "",
           const missing = [];
           const nonWorktree = [];
           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;
@@ -73942,7 +74255,7 @@ ${hintLines.join("\n")}` : "",
         const { promisify: promisify8 } = await import("util");
         const execFileAsync4 = promisify8(execFile5);
         const resolveRepoRootFor = (node) => {
-          const sourceNode = node.clonedFromNodeId ? allNodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : allNodes.find((n) => !n.isLocalWorktree);
+          const sourceNode = node.clonedFromNodeId ? allNodes.find((n) => meshNodeIdMatches(n, node.clonedFromNodeId)) : allNodes.find((n) => !n.isLocalWorktree);
           return sourceNode?.repoRoot || sourceNode?.workspace;
         };
         const repoRootBaseRef = /* @__PURE__ */ new Map();
@@ -74031,7 +74344,7 @@ ${hintLines.join("\n")}` : "",
           }));
         }
         const ordering = orderMeshRefineBatchNodes(changeAreas);
-        const orderedNodes = ordering.order.map((nodeId) => targetNodes.find((n) => n.id === nodeId || n.nodeId === nodeId)).filter((n) => !!n);
+        const orderedNodes = ordering.order.map((nodeId) => targetNodes.find((n) => meshNodeIdMatches(n, nodeId))).filter((n) => !!n);
         const dryRun = args?.dryRun !== false && args?.execute !== true;
         if (dryRun) {
           return {
@@ -74290,7 +74603,7 @@ ${hintLines.join("\n")}` : "",
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
         const mesh = meshRecord?.mesh;
         const allNodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
-        const orderedNodes = nodeIds.map((id) => allNodes.find((n) => n.id === id || n.nodeId === id)).filter((n) => !!n);
+        const orderedNodes = nodeIds.map((id) => allNodes.find((n) => meshNodeIdMatches(n, id))).filter((n) => !!n);
         if (orderedNodes.length === 0) {
           return { success: false, error: "Batch nodes no longer resolvable in mesh", batch: true };
         }
@@ -74396,7 +74709,7 @@ ${hintLines.join("\n")}` : "",
         const terminal = this.terminalRefineJobs.get(key);
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
         const mesh = meshRecord?.mesh;
-        const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+        const node = mesh?.nodes?.find((n) => 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` };
         const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
@@ -74443,7 +74756,7 @@ ${hintLines.join("\n")}` : "",
               try {
                 const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
                 const meshObj = getMesh2(meshId) ?? this.getCachedInlineMesh(meshId);
-                const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => n.id === meshNodeId || n.nodeId === meshNodeId) : void 0;
+                const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, meshNodeId)) : void 0;
                 const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
                 if (bootstrapStatus === "running") {
                   return { success: true, ...launchResult, bootstrapPending: true };
@@ -74488,7 +74801,7 @@ ${hintLines.join("\n")}` : "",
               try {
                 const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
                 const meshObj = getMesh2(dispatchMeshId) ?? this.getCachedInlineMesh(dispatchMeshId);
-                const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => n.id === dispatchNodeId || n.nodeId === dispatchNodeId) : void 0;
+                const nodeObj = Array.isArray(meshObj?.nodes) ? meshObj.nodes.find((n) => meshNodeIdMatches(n, dispatchNodeId)) : void 0;
                 const bootstrapStatus = readStringValue(nodeObj?.worktreeBootstrap?.status);
                 if (bootstrapStatus === "running") {
                   return {
@@ -75753,7 +76066,7 @@ ${hintLines.join("\n")}` : "",
               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) => n.id === nodeId || n.nodeId === nodeId);
+              const node = mesh?.nodes?.find((n) => 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) ? args.sessionIds.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean) : void 0;
@@ -75808,7 +76121,7 @@ ${hintLines.join("\n")}` : "",
             if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
             const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
             const mesh = meshRecord?.mesh;
-            const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+            const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
             if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
             return {
               success: true,
@@ -75830,7 +76143,7 @@ ${hintLines.join("\n")}` : "",
             if (meshId && nodeId) {
               const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
               const mesh = meshRecord?.mesh;
-              const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+              const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
               if (!workspace) {
                 workspace = typeof node?.workspace === "string" ? node.workspace.trim() : "";
               }
@@ -75873,7 +76186,7 @@ ${hintLines.join("\n")}` : "",
             if (isDryRun) {
               const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
               const mesh = meshRecord?.mesh;
-              const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+              const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
               if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
               return {
                 success: true,
@@ -75903,7 +76216,7 @@ ${hintLines.join("\n")}` : "",
             try {
               const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
               const mesh = meshRecord?.mesh;
-              const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
+              const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
               if (node && !args?._meshDirectDispatch && node.isLocalWorktree !== true && args?.force !== true) {
                 const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : "";
                 const nodeMachineId = readMeshNodeMachineId(node) || "";
@@ -76017,7 +76330,7 @@ ${hintLines.join("\n")}` : "",
               const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
               const mesh = meshRecord?.mesh;
               if (!mesh) return { success: false, error: "Mesh not found" };
-              const sourceNode = mesh.nodes?.find((n) => n.id === sourceNodeId || n.nodeId === sourceNodeId);
+              const sourceNode = mesh.nodes?.find((n) => meshNodeIdMatches(n, sourceNodeId));
               if (!sourceNode) return { success: false, error: `Source node '${sourceNodeId}' not found in mesh` };
               const sourceDaemonId = typeof sourceNode.daemonId === "string" ? sourceNode.daemonId.trim() : void 0;
               if (sourceDaemonId && sourceDaemonId !== this.deps.statusInstanceId && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
@@ -76037,9 +76350,9 @@ ${hintLines.join("\n")}` : "",
               });
               let node;
               if (meshRecord.inline) {
-                const { randomUUID: randomUUID14 } = await import("crypto");
+                const { randomUUID: randomUUID15 } = await import("crypto");
                 node = {
-                  id: `node_${randomUUID14().replace(/-/g, "")}`,
+                  id: `node_${randomUUID15().replace(/-/g, "")}`,
                   workspace: result.worktreePath,
                   repoRoot: result.worktreePath,
                   daemonId: sourceNode.daemonId,
@@ -76258,7 +76571,7 @@ ${hintLines.join("\n")}` : "",
               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) => n.id === nodeId || n.nodeId === nodeId);
+              const node = mesh.nodes?.find((n) => 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" };
               const nodeDaemonId = typeof node.daemonId === "string" ? node.daemonId.trim() : void 0;
@@ -76395,14 +76708,14 @@ ${hintLines.join("\n")}` : "",
               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
@@ -76813,10 +77126,11 @@ ${ptyResult.output.slice(-2e3)}`);
               if (!mesh) return { success: false, error: "Mesh not found" };
               const meshHost = resolveMeshHostStatus(mesh);
               const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+              const verboseMissions = args?.verbose === true || args?.compact === false;
               const peekScope = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
               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", {
@@ -76856,7 +77170,7 @@ ${ptyResult.output.slice(-2e3)}`);
               const passivePeerTruthNotAttempted = requireDirectPeerTruth && !refreshRequested && directTruth.directEvidenceCount > 0 && directTruth.peerAttemptedCount === 0;
               const effectiveDirectTruth = passivePeerTruthNotAttempted ? { ...directTruth, unavailableNodeIds: [] } : directTruth;
               const unavailableDirectTruthNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
-              const unavailableNodesAreOnlyRemovedWorktrees = unavailableDirectTruthNodeIds.size > 0 && Array.isArray(mesh.nodes) && mesh.nodes.filter((node) => unavailableDirectTruthNodeIds.has(String(node.id || node.nodeId || ""))).every((node) => node?.isLocalWorktree === true);
+              const unavailableNodesAreOnlyRemovedWorktrees = unavailableDirectTruthNodeIds.size > 0 && Array.isArray(mesh.nodes) && mesh.nodes.filter((node) => unavailableDirectTruthNodeIds.has(normalizeMeshNodeId(node) ?? "")).every((node) => node?.isLocalWorktree === true);
               const directTruthSatisfied = !requireDirectPeerTruth || effectiveDirectTruth.directEvidenceCount > 0 && (effectiveDirectTruth.unavailableNodeIds.length === 0 || unavailableNodesAreOnlyRemovedWorktrees);
               if (requireDirectPeerTruth && !directTruthSatisfied) {
                 const failureResult = {
@@ -76891,14 +77205,13 @@ ${ptyResult.output.slice(-2e3)}`);
               const coordinatorHostname = (0, import_os3.hostname)();
               const selectedCoordinatorNodeId = readStringValue(
                 mesh.coordinator?.preferredNodeId,
-                mesh.nodes?.[0]?.id,
-                mesh.nodes?.[0]?.nodeId
+                normalizeMeshNodeId(mesh.nodes?.[0])
               );
               const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? selectedCoordinatorNodeId : void 0;
               const refreshedAt = (/* @__PURE__ */ 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);
                 const nodeHostname = readMeshNodeHostname(node);
@@ -77120,7 +77433,7 @@ ${ptyResult.output.slice(-2e3)}`);
                 liveSessionRecords: liveMeshSessions
               });
               const { getMeshStatusMissionSummaries: getMeshStatusMissionSummaries2 } = await Promise.resolve().then(() => (init_mesh_missions(), mesh_missions_exports));
-              const missions = getMeshStatusMissionSummaries2(meshId);
+              const missions = getMeshStatusMissionSummaries2(meshId, { verbose: verboseMissions });
               const statusResult = {
                 success: true,
                 meshId: mesh.id,
@@ -77174,7 +77487,7 @@ ${ptyResult.output.slice(-2e3)}`);
                 }))
               };
               const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult;
-              const rememberedStatus = this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
+              const rememberedStatus = verboseMissions ? cacheableStatusResult : this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
               const returnedStatus = {
                 ...rememberedStatus,
                 ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
@@ -84686,7 +84999,7 @@ data: ${JSON.stringify(msg.data)}
         });
       }
     };
-    var import_crypto9 = require("crypto");
+    var import_crypto10 = require("crypto");
     var import_session_host_core10 = require_dist();
     var BASE_KEY_SEQUENCES = {
       enter: "\r",
@@ -84784,7 +85097,7 @@ data: ${JSON.stringify(msg.data)}
         const sessionId = String(options.sessionId || "").trim();
         if (!sessionId) throw new Error("sessionId is required");
         const mode = options.mode || "read";
-        const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto9.randomUUID)().slice(0, 8)}`;
+        const clientId = options.clientId || `raw-terminal-${process.pid}-${(0, import_crypto10.randomUUID)().slice(0, 8)}`;
         const client = options.client || new import_session_host_core10.SessionHostClient({ endpoint: options.endpoint });
         await client.connect();
         const attachResponse = await client.request({