@adhdev/daemon-core 0.9.82-rc.76 → 0.9.82-rc.78

package/dist/index.js

@@ -1133,25 +1133,42 @@ ${userInstruction}`);
   return sections.join("\n\n");
 }
 function buildNodeStatusSection(nodes) {
-  const lines = ["## Current Node Status", ""];
+  const lines = [
+    "## Current Node Status",
+    "",
+    "Node labels are display context, not aliases. Use exact `nodeId` values in mesh tool calls; do not invent shorthand names such as M1/M2 unless they are explicitly configured labels.",
+    ""
+  ];
   for (const n of nodes) {
     const healthIcon = n.health === "online" ? "\u{1F7E2}" : n.health === "dirty" ? "\u{1F7E1}" : n.health === "offline" ? "\u26AB" : "\u{1F534}";
     const sessions = n.activeSessions.length > 0 ? `sessions: ${n.activeSessions.join(", ")}` : "no active sessions";
     const branch = n.git?.branch ? `branch: \`${n.git.branch}\`` : "";
-    lines.push(`- ${healthIcon} **${n.machineLabel}** (${n.nodeId})`);
-    lines.push(`  workspace: \`${n.workspace}\` | ${branch} | ${sessions}`);
+    const context = [
+      n.daemonId ? `daemon: \`${n.daemonId}\`` : "",
+      n.providers?.length ? `providers: ${n.providers.join(", ")}` : ""
+    ].filter(Boolean).join(" | ");
+    lines.push(`- ${healthIcon} **${n.machineLabel}** (nodeId: \`${n.nodeId}\`)`);
+    lines.push(`  workspace: \`${n.workspace}\`${context ? ` | ${context}` : ""} | ${branch} | ${sessions}`);
     if (n.error) lines.push(`  \u26A0\uFE0F ${n.error}`);
   }
   return lines.join("\n");
 }
 function buildNodeConfigSection(mesh) {
-  const lines = ["## Configured Nodes", ""];
+  const lines = [
+    "## Configured Nodes",
+    "",
+    "Node labels are display context, not aliases. Use exact `nodeId` values in mesh tool calls; do not invent shorthand names such as M1/M2 unless they are explicitly configured labels.",
+    ""
+  ];
   for (const n of mesh.nodes) {
     const labels = [];
     if (n.isLocalWorktree) labels.push("worktree");
     if (n.policy?.readOnly) labels.push("read-only");
     const suffix = labels.length ? ` [${labels.join(", ")}]` : "";
-    lines.push(`- **${n.workspace}** (${n.id})${suffix}`);
+    const explicitMachineLabel = typeof n.machineLabel === "string" ? n.machineLabel : "";
+    const explicitLabel = explicitMachineLabel ? ` label: **${explicitMachineLabel}** |` : "";
+    const providerPriority = n.policy?.providerPriority?.length ? ` | providers: ${n.policy.providerPriority.join(", ")}` : "";
+    lines.push(`- ${explicitLabel} nodeId: \`${n.id}\` | workspace: \`${n.workspace}\`${n.daemonId ? ` | daemon: \`${n.daemonId}\`` : ""}${providerPriority}${suffix}`);
   }
   lines.push("", "_Use `mesh_status` to probe live health before delegating work._");
   return lines.join("\n");
@@ -1192,7 +1209,7 @@ function buildRulesSection(coordinatorCliType) {
 - **Clean up worktree nodes.** After a worktree task completes and its changes are merged or checkpointed, call \`mesh_remove_node\` to free resources.
 - **Do not strand completed branches.** A checkpointed or clean feature/worktree branch is not done by itself. Merge/refine it to the mesh default branch, fast-forward obvious clean behind-only branches with \`mesh_fast_forward_node\`, or explicitly report one of \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\` with the next action.
 - **Keep Refinery validation project-configurable.** \`mesh_refine_node\` must execute validation from repo mesh/refine config (for example \`.adhdev/refine.{json,yaml,yml}\`, \`.adhdev/repo-mesh-refine.*\`, or \`repo-mesh.refine.*\`). Heuristics are suggestions/scaffolding only, not the execution path.
-- **Treat submodule reachability as publish-needed.** A \`submodule_reachability_failed\` refine result means the root gitlink points at a submodule commit that is not reachable from the configured submodule remote. Do not retry validation blindly or start code review first. Classify it as \`blocked_review\`, request user approval to push/publish the submodule commit, then rerun \`mesh_refine_node\`.
+- **Treat submodule main reachability as publish-needed.** A \`submodule_reachability_failed\` refine result means the root gitlink points at a submodule commit that is not reachable from the configured submodule remote main branch. Do not treat feature-branch reachability as complete, retry validation blindly, or start code review first. Classify it as \`blocked_review\`, request user approval to push/publish the submodule commit to submodule main, then rerun \`mesh_refine_node\`.
 - **Name worktree branches meaningfully.** Use descriptive names like \`feat/auth-refactor\` or \`fix/build-123\`.${coordinatorNote}`;
 }
 var TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION;
@@ -1239,7 +1256,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
 4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Use \`mesh_view_queue\` to see the status of all pending, assigned, completed, and failed tasks. Do not call \`mesh_read_chat\` again within a few seconds for the same generating session. Use at most one compact \`mesh_read_chat\` check after a completion/approval signal. Handle approvals via \`mesh_approve\`.
 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 its configured remote. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`, ask the user for explicit approval to push/publish the unreachable submodule commit(s), then rerun \`mesh_refine_node\`; do not merge the root branch until the submodule commit(s) are reachable. 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.
+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\`, 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.
 8. **Clean up** \u2014 Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
 9. **Report** \u2014 Summarize what was done, what changed, any issues, and the branch convergence state.
 
@@ -3066,8 +3083,20 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     const result = readRecord(args.metadataEvent.result);
     const code = readNonEmptyString2(result?.code);
     const error = readNonEmptyString2(result?.error);
-    const details = [jobId ? `job_id=${jobId}` : "", code ? `code=${code}` : ""].filter(Boolean).join("; ");
-    return `[System] Refinery async job for ${args.nodeLabel} failed${details ? ` (${details})` : ""}${error ? `: ${error}` : "."} Review the terminal refine event/ledger before retrying.`;
+    const convergenceStatus = readNonEmptyString2(result?.convergenceStatus);
+    const blockedReason = readNonEmptyString2(result?.blockedReason);
+    const nextStep = readNonEmptyString2(result?.nextStep) || readNonEmptyString2(readRecord(result?.finalBranchConvergenceState)?.nextStep);
+    const details = [
+      jobId ? `job_id=${jobId}` : "",
+      code ? `code=${code}` : "",
+      convergenceStatus ? `convergence=${convergenceStatus}` : "",
+      blockedReason ? `reason=${blockedReason}` : ""
+    ].filter(Boolean).join("; ");
+    const parts = [
+      `[System] Refinery async job for ${args.nodeLabel} failed${details ? ` (${details})` : ""}${error ? `: ${error}` : "."}`,
+      nextStep ? `Next step: ${nextStep}` : "Review the terminal refine event/ledger before retrying."
+    ];
+    return parts.join("\n");
   }
   return "";
 }
@@ -3189,7 +3218,8 @@ function injectMeshSystemMessage(components, args) {
       remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
     }
     if (sessionId) {
-      updateSessionTaskStatus(args.meshId, sessionId, "failed");
+      const failedTask = updateSessionTaskStatus(args.meshId, sessionId, "failed");
+      completedTaskForLedger = failedTask ? { id: failedTask.id } : null;
     }
   }
   const ledgerKind = EVENT_TO_LEDGER_KIND[args.event];
@@ -9279,9 +9309,11 @@ function elapsedSince(value, now) {
   return Number.isFinite(started) ? Math.max(0, now - started) : 0;
 }
 function sessionStatusFromNodes(nodes, nodeId, sessionId) {
-  if (!nodeId || !sessionId || !Array.isArray(nodes)) return void 0;
+  if (!Array.isArray(nodes)) return {};
+  if (!nodeId) return { staleReason: "direct task has no node id" };
   const node = nodes.find((item) => readString2(item?.id) === nodeId || readString2(item?.nodeId) === nodeId || readString2(item?.node_id) === nodeId);
-  if (!node) return void 0;
+  if (!node) return { staleReason: "direct task node is no longer in the live mesh" };
+  if (!sessionId) return {};
   const candidates = [];
   for (const value of [node.sessions, node.activeSessions, node.active_sessions, node.lastProbe?.sessions, node.last_probe?.sessions, node.lastProbe?.status?.sessions, node.last_probe?.status?.sessions]) {
     if (Array.isArray(value)) candidates.push(...value);
@@ -9290,16 +9322,18 @@ function sessionStatusFromNodes(nodes, nodeId, sessionId) {
     if (value && typeof value === "object") candidates.push(value);
   }
   const session = candidates.find((item) => {
+    if (typeof item === "string") return item === sessionId;
     const id = readString2(item?.id) || readString2(item?.sessionId) || readString2(item?.session_id) || readString2(item?.runtimeSessionId) || readString2(item?.instanceId);
     return id === sessionId;
   });
-  if (!session) return void 0;
+  if (!session) return { staleReason: "direct task session is not present in live session records" };
+  if (typeof session === "string") return {};
   const raw = `${readString2(session.status) || ""} ${readString2(session.lifecycle) || ""} ${readString2(session.state) || ""} ${readString2(session.activeChat?.status) || ""}`.toLowerCase();
-  if (raw.includes("approval")) return "awaiting_approval";
-  if (raw.includes("generating") || raw.includes("running") || raw.includes("busy")) return "generating";
-  if (raw.includes("failed") || raw.includes("stopped") || raw.includes("terminated") || raw.includes("exited")) return "failed";
-  if (raw.includes("idle") || raw.includes("waiting_input") || raw.includes("ready")) return "idle";
-  return void 0;
+  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" };
+  if (raw.includes("idle") || raw.includes("waiting_input") || raw.includes("ready")) return { status: "idle" };
+  return {};
 }
 function isDirectDispatch(entry) {
   if (entry.kind !== "task_dispatched") return false;
@@ -9346,15 +9380,17 @@ function buildMeshActiveWorkSummary(activeWork) {
     failedCount: statusCounts.failed,
     idleCount: statusCounts.idle,
     sourceCounts,
-    statusCounts
+    statusCounts,
+    staleDirectCount: activeWork.filter((item) => item.source === "direct" && item.staleReason).length
   };
 }
 function buildMeshActiveWork(opts) {
   const now = opts.now ?? Date.now();
   const records = [];
+  const staleDirectWork = [];
   for (const task of opts.queue || []) {
     if (task.status !== "pending" && task.status !== "assigned") continue;
-    const { title, summary } = summarizeMessage(task.message || "");
+    const { title, summary: summary2 } = summarizeMessage(task.message || "");
     records.push({
       taskId: task.id,
       source: "queue",
@@ -9362,7 +9398,7 @@ function buildMeshActiveWork(opts) {
       nodeId: task.assignedNodeId || task.targetNodeId,
       sessionId: task.assignedSessionId || task.targetSessionId,
       taskTitle: title,
-      taskSummary: summary,
+      taskSummary: summary2,
       message: task.message,
       taskMode: task.taskMode,
       createdAt: task.createdAt,
@@ -9377,13 +9413,13 @@ function buildMeshActiveWork(opts) {
     const taskId = directDispatchTaskId(dispatch);
     const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
     const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
-    const liveStatus = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
-    const status = terminalStatus || liveStatus || "assigned";
+    const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
+    const status = terminalStatus || live.status || "assigned";
     const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
     if (terminalRow && opts.includeTerminalDirect !== true) continue;
     const message = readString2(dispatch.payload?.message) || readString2(dispatch.payload?.summary) || "";
-    const { title, summary } = summarizeMessage(message);
-    records.push({
+    const { title, summary: summary2 } = summarizeMessage(message);
+    const record = {
       taskId,
       source: "direct",
       status,
@@ -9391,7 +9427,7 @@ function buildMeshActiveWork(opts) {
       sessionId: dispatch.sessionId,
       providerType: dispatch.providerType || readString2(dispatch.payload?.providerType),
       taskTitle: readString2(dispatch.payload?.taskTitle) || title,
-      taskSummary: readString2(dispatch.payload?.taskSummary) || summary,
+      taskSummary: readString2(dispatch.payload?.taskSummary) || summary2,
       message,
       taskMode: readString2(dispatch.payload?.taskMode),
       createdAt: dispatch.timestamp,
@@ -9400,11 +9436,20 @@ function buildMeshActiveWork(opts) {
       elapsedMs: elapsedSince(dispatch.timestamp, now),
       terminal: terminalRow,
       terminalKind: terminal?.kind,
-      terminalAt: terminal?.timestamp
-    });
+      terminalAt: terminal?.timestamp,
+      staleReason: live.staleReason
+    };
+    if (live.staleReason && !terminalRow) {
+      staleDirectWork.push(record);
+      continue;
+    }
+    records.push(record);
   }
   records.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-  return { activeWork: records, summary: buildMeshActiveWorkSummary(records) };
+  staleDirectWork.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+  const summary = buildMeshActiveWorkSummary(records);
+  summary.staleDirectCount = staleDirectWork.length;
+  return { activeWork: records, staleDirectWork, summary };
 }
 
 // src/index.ts
@@ -19691,23 +19736,28 @@ var CliProviderInstance = class {
     if (hasNonEmptyCliModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
     return !this.hasAdapterPendingResponse();
   }
-  getCompletedFinalizationBlockReason(latestVisibleStatus) {
-    if (latestVisibleStatus !== "idle") return `status:${latestVisibleStatus}`;
+  getCompletedFinalizationBlock(latestVisibleStatus) {
+    if (latestVisibleStatus !== "idle") return { reason: `status:${latestVisibleStatus}`, terminal: true };
     const adapterAny = this.adapter;
-    if (adapterAny?.isWaitingForResponse === true) return "adapter_waiting_for_response";
-    if (adapterAny?.currentTurnScope) return "adapter_turn_scope_active";
+    if (adapterAny?.isWaitingForResponse === true) return { reason: "adapter_waiting_for_response", terminal: true };
+    if (adapterAny?.currentTurnScope) return { reason: "adapter_turn_scope_active", terminal: true };
+    if (this.hasAdapterPendingResponse()) return { reason: "adapter_pending_response", terminal: true };
     const partial = typeof this.adapter.getPartialResponse === "function" ? this.adapter.getPartialResponse() : "";
-    if (typeof partial === "string" && partial.trim()) return "partial_response_pending";
+    if (typeof partial === "string" && partial.trim()) return { reason: "partial_response_pending", terminal: true };
     let parsed;
     try {
       parsed = this.adapter.getScriptParsedStatus();
     } catch (error) {
-      return `parse_error:${error?.message || String(error)}`;
+      return { reason: `parse_error:${error?.message || String(error)}` };
     }
     const parsedStatus = typeof parsed?.status === "string" ? parsed.status : "unknown";
-    if (parsedStatus !== "idle") return `parsed_status:${parsedStatus}`;
-    if (parsed?.activeModal || parsed?.modal) return "parsed_modal_active";
-    if (!this.completionHasFinalAssistantMessage(parsed?.messages)) return "missing_final_assistant";
+    if (parsedStatus !== "idle") {
+      const adapterStatus = this.adapter.getStatus({ allowParse: false });
+      if (this.shouldSuppressStaleParsedBusyStatus(parsed, adapterStatus)) return null;
+      return { reason: `parsed_status:${parsedStatus}`, terminal: isCliGeneratingLikeStatus(parsedStatus) };
+    }
+    if (parsed?.activeModal || parsed?.modal) return { reason: "parsed_modal_active", terminal: true };
+    if (!this.completionHasFinalAssistantMessage(parsed?.messages)) return { reason: "missing_final_assistant" };
     return null;
   }
   scheduleCompletedDebounceFlush(delayMs) {
@@ -19729,10 +19779,11 @@ var CliProviderInstance = class {
       this.completedDebounceTimer = null;
       return;
     }
-    const blockReason = this.getCompletedFinalizationBlockReason(latestVisibleStatus);
-    if (blockReason) {
+    const block2 = this.getCompletedFinalizationBlock(latestVisibleStatus);
+    if (block2) {
+      const blockReason = block2.reason;
       const waitedMs = Date.now() - pending.firstObservedAt;
-      if (waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
+      if (block2.terminal || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
         if (pending.loggedBlockReason !== blockReason) {
           LOG.info("CLI", `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
           pending.loggedBlockReason = blockReason;
@@ -21596,6 +21647,47 @@ var BUSY_AGENT_STATUSES = /* @__PURE__ */ new Set(["generating", "running", "str
 function normalizeAgentStatus(value) {
   return typeof value === "string" ? value.trim().toLowerCase() : "";
 }
+function hasNonEmptyModalButtons2(activeModal) {
+  const buttons = activeModal?.buttons;
+  return Array.isArray(buttons) && buttons.some((button) => String(button || "").trim().length > 0);
+}
+function hasAdapterPendingResponse(adapter) {
+  if (adapter?.isWaitingForResponse === true) return true;
+  if (adapter?.currentTurnScope) return true;
+  try {
+    if (typeof adapter?.isProcessing === "function" && adapter.isProcessing()) return true;
+  } catch {
+  }
+  try {
+    const partial = typeof adapter?.getPartialResponse === "function" ? adapter.getPartialResponse() : "";
+    if (typeof partial === "string" && partial.trim()) return true;
+  } catch {
+  }
+  return false;
+}
+function shouldSuppressStaleParsedBusyStatus(adapterStatus, parsedStatus, adapter) {
+  const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+  if (!BUSY_AGENT_STATUSES.has(parsedRawStatus)) return false;
+  if (adapterStatus !== "idle") return false;
+  if (hasNonEmptyModalButtons2(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+  return !hasAdapterPendingResponse(adapter);
+}
+function getEffectiveAgentSendStatus(adapter) {
+  const adapterStatus = normalizeAgentStatus(adapter?.getStatus?.({ allowParse: false })?.status ?? adapter?.getStatus?.()?.status);
+  if (adapterStatus && adapterStatus !== "idle") return adapterStatus;
+  if (adapterStatus !== "idle") return adapterStatus;
+  if (typeof adapter?.getScriptParsedStatus !== "function") return adapterStatus;
+  try {
+    const parsedStatus = adapter.getScriptParsedStatus();
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (BUSY_AGENT_STATUSES.has(parsedRawStatus) && !shouldSuppressStaleParsedBusyStatus(adapterStatus, parsedStatus, adapter)) {
+      return parsedRawStatus;
+    }
+  } catch {
+    return adapterStatus;
+  }
+  return adapterStatus;
+}
 var chalkModule = import_chalk.default;
 var chalkApi = typeof chalkModule.yellow === "function" ? chalkModule : chalkModule.default || null;
 function colorize(color, text) {
@@ -22370,7 +22462,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (!found) throw new Error(`CLI agent not running: ${agentType}`);
         const { adapter, key } = found;
         if (action === "send_chat") {
-          const currentStatus = normalizeAgentStatus(adapter.getStatus?.()?.status);
+          const currentStatus = getEffectiveAgentSendStatus(adapter);
           if (BUSY_AGENT_STATUSES.has(currentStatus)) {
             return {
               success: false,
@@ -25859,6 +25951,17 @@ function readGitSubmodules(value, parentRepoRoot) {
   }).filter((entry) => entry !== null);
   return submodules.length > 0 ? submodules : void 0;
 }
+function buildMeshNodeDisplayLabel(node, nodeId, providerPriority) {
+  const explicit = readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias);
+  if (explicit) return explicit;
+  const workspace = readStringValue(node.workspace, node.repoRoot, node.repo_root);
+  const workspaceName = workspace ? (0, import_path8.basename)(workspace) : void 0;
+  const host = readStringValue(node.hostname, node.host, node.daemonId, node.daemon_id, node.machineId, node.machine_id);
+  const provider = providerPriority[0] || (Array.isArray(node.providers) ? readStringValue(...node.providers) : void 0);
+  const parts = [workspaceName, host, provider].filter(Boolean);
+  if (parts.length > 0) return parts.join(" \xB7 ");
+  return nodeId || "unidentified mesh node";
+}
 function normalizeInlineMeshGitStatus(status, node, options) {
   const isGitRepo = readBooleanValue(status.isGitRepo);
   if (!Object.keys(status).length || isGitRepo === void 0) return void 0;
@@ -26529,7 +26632,7 @@ function recordMeshRefineStage(stages, stage, status, startedAt, details) {
 }
 function buildSubmodulePublishRequiredNextStep(entries) {
   const refs = entries.map((entry) => `${entry.path}@${entry.commit}`).join(", ");
-  return `Ask the user for explicit approval to push/publish the unreachable submodule commit(s) (${refs}) to their configured submodule remote(s), then rerun mesh_refine_node. Do not merge the root branch until every submodule gitlink commit is reachable from its configured remote.`;
+  return `Ask the user for explicit approval to push/publish the unreachable submodule commit(s) (${refs}) to the configured submodule remote main branch, then rerun mesh_refine_node. Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.`;
 }
 async function computeGitPatchId(cwd, fromRef, toRef) {
   const { execFileSync: execFileSync3 } = await import("child_process");
@@ -26616,12 +26719,13 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
       });
       return String(stdout || "");
     };
-    const verifyRemoteCommitReachable = async (remoteUrl, commit) => {
+    const verifyRemoteMainContainsCommit = async (remoteUrl, commit, branch = "main") => {
       const probeDir = fs11.mkdtempSync((0, import_path8.join)((0, import_os3.tmpdir)(), "adhdev-submodule-reachability-"));
       try {
         await runGit2(probeDir, ["init", "-q"]);
-        await runGit2(probeDir, ["-c", "protocol.file.allow=always", "fetch", "--depth=1", remoteUrl, commit]);
+        await runGit2(probeDir, ["-c", "protocol.file.allow=always", "fetch", "--depth=1", remoteUrl, `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
         await runGit2(probeDir, ["cat-file", "-e", `${commit}^{commit}`]);
+        await runGit2(probeDir, ["merge-base", "--is-ancestor", commit, `refs/remotes/origin/${branch}`]);
       } finally {
         fs11.rmSync(probeDir, { recursive: true, force: true });
       }
@@ -26665,15 +26769,18 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
             entries.push(entry);
             continue;
           }
-          await verifyRemoteCommitReachable(remoteUrl, gitlink.commit);
+          entry.remoteMainBranch = "main";
+          await verifyRemoteMainContainsCommit(remoteUrl, gitlink.commit, "main");
           entry.fetchedFromOrigin = true;
           entry.remoteReachable = true;
+          entry.remoteMainReachable = true;
           entry.reachable = true;
         } catch (e) {
           entry.remoteReachable = false;
+          entry.remoteMainReachable = false;
           entry.publishRequired = true;
           const details = truncateValidationOutput(e?.stderr || e?.message || String(e));
-          entry.error = `Submodule remote reachability check failed for origin: ${details}`;
+          entry.error = `Submodule remote main reachability check failed for origin/main: ${details}`;
         }
       } catch (e) {
         entry.error = truncateValidationOutput(e?.message || String(e));
@@ -27821,6 +27928,8 @@ var DaemonCommandRouter = class {
           remote: entry.remote,
           remoteUrl: entry.remoteUrl,
           remoteReachable: entry.remoteReachable,
+          remoteMainBranch: entry.remoteMainBranch,
+          remoteMainReachable: entry.remoteMainReachable,
           error: entry.error
         })),
         error: submoduleReachability.error
@@ -27833,13 +27942,13 @@ var DaemonCommandRouter = class {
           convergenceStatus: "blocked_review",
           publishRequired: true,
           blockedReason: "submodule_publish_required",
-          error: "Refinery submodule reachability preflight failed because one or more submodule gitlink commits are not reachable from their configured remote; merge/refine cleanup was not attempted.",
+          error: "Refinery submodule reachability preflight failed because one or more submodule gitlink commits are not reachable from their configured remote main branch; merge/refine cleanup was not attempted.",
           nextStep,
           nextSteps: [
             "Ask the user for explicit approval before pushing or publishing any submodule commit.",
-            "Push/publish each unreachable submodule commit to the configured submodule remote shown in the evidence.",
+            "Push/publish each unreachable submodule commit to the configured submodule remote main branch shown in the evidence.",
             "Rerun mesh_refine_node after remote reachability is confirmed.",
-            "Do not merge the root branch until every submodule gitlink commit is reachable from its configured remote."
+            "Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main."
           ],
           unreachableSubmoduleCommits: submoduleReachability.unreachable.map((entry) => ({
             path: entry.path,
@@ -27847,6 +27956,8 @@ var DaemonCommandRouter = class {
             remote: entry.remote,
             remoteUrl: entry.remoteUrl,
             remoteReachable: entry.remoteReachable,
+            remoteMainBranch: entry.remoteMainBranch,
+            remoteMainReachable: entry.remoteMainReachable,
             error: entry.error
           })),
           branch,
@@ -29721,7 +29832,8 @@ ${block2}`);
             ) || Boolean(meshRecord?.inline && nodeIndex === 0);
             const status = {
               nodeId,
-              machineLabel: node.machineLabel || node.id || node.nodeId,
+              machineLabel: buildMeshNodeDisplayLabel(node, nodeId, providerPriority),
+              labelSource: readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias) ? "explicit_metadata" : "workspace_host_provider_context",
               workspace: node.workspace,
               repoRoot: node.repoRoot,
               isLocalWorktree: node.isLocalWorktree,