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

package/dist/index.mjs

@@ -270,10 +270,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "396cb9c4084ea658cd3606b76948987cd875f138" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "396cb9c4" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:42:37.821Z" : 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 version = 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:13:51.625Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -344,6 +344,15 @@ async function getGitRepoStatus(workspace, options = {}) {
     );
   }
 }
+function isNonRuntimeRootFile(file) {
+  const base = file.slice(file.lastIndexOf("/") + 1);
+  if (/^\.(?:verify|marker|converge|ff-verify|patch-equiv|live-verify)\b/i.test(base)) return true;
+  if (/(?:^|\/)docs\//i.test(file)) 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);
@@ -352,18 +361,18 @@ async function classifyDaemonBuildChange(repoPath, buildCommit, options) {
       return { isDaemonAffecting: true, affectedPackages: [] };
     }
     const pkgs = /* @__PURE__ */ new Set();
-    let sawNonPackageOrUnknown = false;
+    let sawRuntimeAmbiguousNonPackage = false;
     for (const file of files) {
       const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
       if (!match) {
-        sawNonPackageOrUnknown = true;
+        if (!isNonRuntimeRootFile(file)) 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: [] };
   }
@@ -390,7 +399,8 @@ async function detectDaemonBuildBehind(repo, submodules, options) {
         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,
@@ -1995,7 +2005,7 @@ function buildRulesSection(coordinatorCliType) {
 - **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.
@@ -2046,7 +2056,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.
@@ -4389,6 +4399,34 @@ var init_mesh_runtime_store = __esm({
         ).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;
+      }
     };
   }
 });
@@ -4396,6 +4434,7 @@ var init_mesh_runtime_store = __esm({
 // src/mesh/mesh-missions.ts
 var mesh_missions_exports = {};
 __export(mesh_missions_exports, {
+  GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
   MESH_MISSION_STATUSES: () => MESH_MISSION_STATUSES,
   buildMissionPromptSection: () => buildMissionPromptSection,
   getActiveMeshMissionSummaries: () => getActiveMeshMissionSummaries,
@@ -4468,12 +4507,23 @@ function summarizeMeshMission(meshId, mission) {
 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);
@@ -4493,13 +4543,14 @@ function buildMissionPromptSection(meshId) {
   );
   return lines.join("\n");
 }
-var MESH_MISSION_STATUSES;
+var MESH_MISSION_STATUSES, GOAL_PREVIEW_MAX;
 var init_mesh_missions = __esm({
   "src/mesh/mesh-missions.ts"() {
     "use strict";
     init_mesh_runtime_store();
     init_mesh_work_queue();
     MESH_MISSION_STATUSES = ["active", "paused", "completed", "abandoned"];
+    GOAL_PREVIEW_MAX = 120;
   }
 });
 
@@ -6178,11 +6229,225 @@ var init_mesh_fast_forward = __esm({
   }
 });
 
+// ../mesh-shared/dist/index.mjs
+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 error = readString5(submodule.error);
+    if (error) result.error = error;
+    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 error = 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 } : {},
+    ...error ? { error } : {}
+  };
+}
+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 record = node && typeof node === "object" ? node : {};
+  return readString5(record.id, record.nodeId, record.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 record = readRecord3(status);
+  if (!Object.keys(record).length) return null;
+  const submodules = Array.isArray(record.submodules) ? record.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(record.isGitRepo),
+    workspace: readString5(record.workspace) ?? null,
+    repoRoot: readString5(record.repoRoot, record.repo_root) ?? null,
+    branch: readString5(record.branch) ?? null,
+    upstream: readString5(record.upstream) ?? null,
+    upstreamStatus: readString5(record.upstreamStatus, record.upstream_status) ?? null,
+    headCommit: readString5(record.headCommit, record.head_commit)?.slice(0, 12) ?? null,
+    ahead: readNumber(record.ahead) ?? null,
+    behind: readNumber(record.behind) ?? null,
+    dirtyCounts: {
+      staged: readNumber(record.staged) ?? 0,
+      modified: readNumber(record.modified) ?? 0,
+      untracked: readNumber(record.untracked) ?? 0,
+      deleted: readNumber(record.deleted) ?? 0,
+      renamed: readNumber(record.renamed) ?? 0
+    },
+    lastCheckedAt: readNumber(record.lastCheckedAt, record.last_checked_at) ?? null,
+    submoduleCount: submodules.length,
+    submodules
+  };
+}
+var init_dist = __esm({
+  "../mesh-shared/dist/index.mjs"() {
+    "use strict";
+  }
+});
+
 // src/mesh/mesh-events-utils.ts
 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) {
@@ -6206,13 +6471,13 @@ function resolveEventSessionId(event, fallback) {
   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;
@@ -6290,10 +6555,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);
@@ -6314,10 +6579,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 error = readNonEmptyString2(result?.error);
     const validationStatus = readNonEmptyString2(validationSummary?.status);
@@ -6367,9 +6632,9 @@ function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
   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) {
@@ -6381,13 +6646,13 @@ function hasPendingRefineTerminalEventDuplicate(event) {
   );
 }
 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 [
@@ -6455,15 +6720,15 @@ function refineTerminalEventFromLedger(meshId, pending) {
   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,
@@ -7068,7 +7333,7 @@ function buildLongGeneratingCompletionReconciliation(args) {
   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(
@@ -7383,6 +7648,111 @@ var init_mesh_routing = __esm({
   }
 });
 
+// src/mesh/mesh-unresolved-forward-outbox.ts
+import { randomUUID as randomUUID9 } from "crypto";
+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: randomUUID9(),
+      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) {
+      LOG.info("MeshEvents", `Durably queued unresolved-delegate ${event} for coordinator ${target} (outbox)`);
+    }
+    return true;
+  } catch (e) {
+    LOG.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) {
+      LOG.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 UNRESOLVED_FORWARD_OUTBOX_MESH_ID, UNRESOLVED_FORWARD_MAX_AGE_MS;
+var init_mesh_unresolved_forward_outbox = __esm({
+  "src/mesh/mesh-unresolved-forward-outbox.ts"() {
+    "use strict";
+    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;
+  }
+});
+
 // src/mesh/mesh-events-coordinator.ts
 import { existsSync as existsSync14 } from "fs";
 function resolveCoordinatorDrainDaemonIds(components) {
@@ -7788,7 +8158,7 @@ async function resolveUsableProvider(components, nodeId, node, requiredTags) {
   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);
@@ -8017,7 +8387,7 @@ async function triggerMeshQueue(components, meshId) {
 }
 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 (!existsSync14(workspace)) return;
@@ -8518,12 +8888,25 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
     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) => {
-    LOG.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) {
+      LOG.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) => {
+    LOG.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued for retry`);
   });
-  LOG.info("MeshEvents", `Fallback-forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
+  LOG.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") {
@@ -8604,7 +8987,9 @@ var init_mesh_events_coordinator = __esm({
     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;
@@ -8718,6 +9103,13 @@ async function runMeshReconcileTick(components) {
       return void 0;
     }
   })();
+  if (dispatchMeshCommand) {
+    try {
+      await retryUnresolvedDelegateForwards(components);
+    } catch (e) {
+      LOG.warn("MeshReconcile", `Unresolved-delegate forward retry failed: ${e?.message || e}`);
+    }
+  }
   if (dispatchMeshCommand) {
     for (const mesh of listMeshes()) {
       const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
@@ -8771,6 +9163,28 @@ async function runMeshReconcileTick(components) {
     }
   }
 }
+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) {
+      LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued`);
+      continue;
+    }
+    if (result && result.success === false) {
+      LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued`);
+      continue;
+    }
+    ackUnresolvedDelegateForward(entry.id);
+    LOG.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;
@@ -8847,6 +9261,7 @@ var init_mesh_reconcile_loop = __esm({
     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;
   }
@@ -17191,9 +17606,10 @@ function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
 init_mesh_work_queue();
 
 // src/mesh/mesh-active-work.ts
+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) {
@@ -17208,7 +17624,7 @@ function elapsedSince(value, now) {
 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 = [];
@@ -17232,12 +17648,12 @@ function sessionStatusFromNodes(nodes, nodeId, sessionId) {
   }
   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" };
@@ -17248,14 +17664,14 @@ function isDirectDispatch(entry) {
   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;
@@ -17378,7 +17794,7 @@ function buildMeshActiveWork(opts) {
       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 record = {
@@ -17387,11 +17803,11 @@ function buildMeshActiveWork(opts) {
         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,
@@ -17426,7 +17842,7 @@ function buildMeshActiveWork(opts) {
       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 record = {
@@ -17435,11 +17851,11 @@ function buildMeshActiveWork(opts) {
         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,
@@ -21783,7 +22199,7 @@ var ExtensionProviderInstance = class {
     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,
@@ -22450,7 +22866,7 @@ var IdeProviderInstance = class {
     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,
@@ -23929,7 +24345,7 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
 import * as fs6 from "fs";
 import * as os8 from "os";
 import * as path13 from "path";
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 init_logger();
 
 // src/logging/debug-trace.ts
@@ -25470,7 +25886,7 @@ function safeBundleIdSegment(value, fallback) {
 function createChatDebugBundleId(targetSessionId) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "").replace("T", "T").replace("Z", "Z");
   const sessionSegment = safeBundleIdSegment(targetSessionId, "unknown-session");
-  return `chat-debug-${timestamp}-${sessionSegment}-${randomUUID10().slice(0, 8)}`;
+  return `chat-debug-${timestamp}-${sessionSegment}-${randomUUID11().slice(0, 8)}`;
 }
 function buildChatDebugBundleSummary(bundle) {
   const target = bundle.target && typeof bundle.target === "object" ? bundle.target : {};
@@ -31998,22 +32414,7 @@ var CliProviderInstance = class _CliProviderInstance {
     };
   }
   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,
@@ -39345,207 +39746,7 @@ function getAvailableIdeIds() {
 init_config();
 init_cli_detector();
 init_git_status();
-
-// ../mesh-shared/dist/index.mjs
-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 error = readString6(submodule.error);
-    if (error) result.error = error;
-    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 error = 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 } : {},
-    ...error ? { error } : {}
-  };
-}
-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 record = readRecord5(status);
-  if (!Object.keys(record).length) return null;
-  const submodules = Array.isArray(record.submodules) ? record.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(record.isGitRepo),
-    workspace: readString6(record.workspace) ?? null,
-    repoRoot: readString6(record.repoRoot, record.repo_root) ?? null,
-    branch: readString6(record.branch) ?? null,
-    upstream: readString6(record.upstream) ?? null,
-    upstreamStatus: readString6(record.upstreamStatus, record.upstream_status) ?? null,
-    headCommit: readString6(record.headCommit, record.head_commit)?.slice(0, 12) ?? null,
-    ahead: readNumber(record.ahead) ?? null,
-    behind: readNumber(record.behind) ?? null,
-    dirtyCounts: {
-      staged: readNumber(record.staged) ?? 0,
-      modified: readNumber(record.modified) ?? 0,
-      untracked: readNumber(record.untracked) ?? 0,
-      deleted: readNumber(record.deleted) ?? 0,
-      renamed: readNumber(record.renamed) ?? 0
-    },
-    lastCheckedAt: readNumber(record.lastCheckedAt, record.last_checked_at) ?? null,
-    submoduleCount: submodules.length,
-    submodules
-  };
-}
-
-// src/commands/router.ts
+init_dist();
 init_logger();
 
 // src/logging/command-log.ts
@@ -40625,7 +40826,10 @@ function summarizeRepoMeshStatusDebug(status) {
     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,
@@ -40870,7 +41074,23 @@ function inlineMeshCarriesTransientNodeTruth(inlineMesh) {
   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;
@@ -40972,7 +41192,7 @@ function deriveMeshNodeHealthFromGit(git) {
   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);
@@ -41251,7 +41471,7 @@ async function hydrateInlineMeshDirectTruth(args) {
   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(
@@ -41382,7 +41602,7 @@ function buildHistoricalMeshSessions(args) {
   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);
@@ -41507,9 +41727,13 @@ function resolveRefineryAutoPublishSubmoduleMainCommits(mesh, workspace) {
   }
   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
@@ -41578,8 +41802,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",
@@ -41775,6 +42000,14 @@ function readChangedPathKinds(repoRoot, fromRef, toRef) {
     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(pathResolve2(repoRoot, path40), baseCommit, branchCommit);
+  });
+}
 function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
   const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path40) => {
     const baseCommit = readTreeObject(repoRoot, baseHead, path40);
@@ -41824,20 +42057,95 @@ function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
   }
   return { trivial: true, gitlinks: changedGitlinks };
 }
+function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderCommit) {
+  try {
+    const tree = execFileSync5("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 = pathJoin(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+    const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
+    try {
+      execFileSync5("git", ["read-tree", tree], { cwd: repoRoot, env, stdio: "ignore" });
+      execFileSync5("git", ["update-index", "--index-info"], {
+        cwd: repoRoot,
+        env,
+        input: `${updates}
+`,
+        encoding: "utf8",
+        stdio: ["pipe", "ignore", "ignore"]
+      });
+      const newTree = execFileSync5("git", ["write-tree"], { cwd: repoRoot, env, 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 = execFileSync5("git", ["rev-parse", `${baseHead}^{tree}`], {
+    const branchGitlinks = gitlinks.filter((entry) => entry.branchCommit);
+    const gitlinkPaths = branchGitlinks.map((entry) => entry.path);
+    const mergeBase = execFileSync5("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 = execFileSync5("git", ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
+            cwd: repoRoot,
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024
+          }).trim();
+          const oursEqCommit = execFileSync5("git", ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
+            cwd: repoRoot,
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024
+          }).trim();
+          const theirsEqCommit = execFileSync5("git", ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
+            cwd: repoRoot,
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024
+          }).trim();
+          const mergeOut = execFileSync5("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 || execFileSync5("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 = pathJoin(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
     try {
-      execFileSync5("git", ["read-tree", baseTree], { cwd: repoRoot, env, stdio: "ignore" });
+      execFileSync5("git", ["read-tree", contentTree], { cwd: repoRoot, env, stdio: "ignore" });
       execFileSync5("git", ["update-index", "--index-info"], {
         cwd: repoRoot,
         env,
@@ -42497,7 +42805,7 @@ function normalizeStandaloneHostCommandUrl(hostAddress) {
 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;
@@ -42553,7 +42861,7 @@ var DaemonCommandRouter = class {
       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);
@@ -42666,7 +42974,7 @@ var DaemonCommandRouter = class {
   }
   warmInlineMeshCache(meshId, inlineMesh) {
     if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
-    const sanitizedInlineMesh = sanitizeInlineMesh(inlineMesh);
+    const sanitizedInlineMesh = sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh));
     const cached2 = this.inlineMeshCache.get(meshId);
     if (cached2) {
       const merged = reconcileInlineMeshCache(cached2, sanitizedInlineMesh);
@@ -42683,7 +42991,7 @@ var DaemonCommandRouter = class {
       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" };
@@ -42719,17 +43027,19 @@ var DaemonCommandRouter = class {
     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();
@@ -42760,7 +43070,7 @@ var DaemonCommandRouter = class {
       };
     }
     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" };
@@ -43403,12 +43713,12 @@ var DaemonCommandRouter = class {
     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");
@@ -44043,7 +44353,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;
@@ -44072,7 +44382,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();
@@ -44161,7 +44471,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 {
@@ -44420,7 +44730,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 };
     }
@@ -44526,7 +44836,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;
@@ -44573,7 +44883,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 };
@@ -44618,7 +44928,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 {
@@ -45883,7 +46193,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;
@@ -45938,7 +46248,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,
@@ -45960,7 +46270,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() : "";
           }
@@ -46003,7 +46313,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,
@@ -46033,7 +46343,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) || "";
@@ -46147,7 +46457,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) {
@@ -46167,9 +46477,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,
@@ -46388,7 +46698,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;
@@ -46525,14 +46835,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
@@ -46943,10 +47253,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", {
@@ -46986,7 +47297,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 = {
@@ -47021,14 +47332,13 @@ ${ptyResult.output.slice(-2e3)}`);
           const coordinatorHostname = osHostname();
           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);
@@ -47250,7 +47560,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,
@@ -47304,7 +47614,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 } : {},
@@ -54860,7 +55170,7 @@ var SessionHostPtyTransportFactory = class {
 };
 
 // src/cli-adapters/raw-terminal-io.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 import {
   SessionHostClient as SessionHostClient2
 } from "@adhdev/session-host-core";
@@ -54960,7 +55270,7 @@ var RawTerminalAttachment = class _RawTerminalAttachment {
     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}-${randomUUID13().slice(0, 8)}`;
+    const clientId = options.clientId || `raw-terminal-${process.pid}-${randomUUID14().slice(0, 8)}`;
     const client = options.client || new SessionHostClient2({ endpoint: options.endpoint });
     await client.connect();
     const attachResponse = await client.request({