@adhdev/daemon-core 0.9.82-rc.77 → 0.9.82-rc.79

package/dist/index.mjs

@@ -1128,25 +1128,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");
@@ -1187,7 +1204,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;
@@ -1234,7 +1251,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.
 
@@ -3046,23 +3063,54 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
     const result = readRecord(args.metadataEvent.result);
     const validationSummary = readRecord(result?.validationSummary);
+    const patchEquivalence = readRecord(result?.patchEquivalence);
+    const finalConvergence = readRecord(result?.finalBranchConvergenceState);
     const validationStatus = readNonEmptyString2(validationSummary?.status);
+    const patchStatus = readNonEmptyString2(patchEquivalence?.status) || (patchEquivalence?.equivalent === true ? "passed" : "");
     const into = readNonEmptyString2(result?.into);
     const branch = readNonEmptyString2(result?.branch);
+    const mergeStatus = result?.merged === true ? "merged" : readNonEmptyString2(finalConvergence?.status);
+    const convergenceStatus = readNonEmptyString2(finalConvergence?.status);
+    const nextStep = readNonEmptyString2(result?.nextStep) || readNonEmptyString2(finalConvergence?.nextStep) || "Continue from the updated mesh state.";
     const details = [
       jobId ? `job_id=${jobId}` : "",
       branch && into ? `${branch}\u2192${into}` : "",
-      validationStatus ? `validation=${validationStatus}` : ""
+      validationStatus ? `validation=${validationStatus}` : "",
+      patchStatus ? `patch_equivalence=${patchStatus}` : "",
+      mergeStatus ? `merge=${mergeStatus}` : "",
+      convergenceStatus ? `final_convergence=${convergenceStatus}` : ""
     ].filter(Boolean).join("; ");
-    return `[System] Refinery async job for ${args.nodeLabel} completed successfully${details ? ` (${details})` : ""}. The worktree was merged and cleanup completed; continue from the updated mesh state.`;
+    return `[System] Refinery async job for ${args.nodeLabel} completed successfully${details ? ` (${details})` : ""}.
+Next step: ${nextStep}`;
   }
   if (args.event === "refine:failed") {
     const jobId = readRefineJobId({ metadataEvent: args.metadataEvent });
     const result = readRecord(args.metadataEvent.result);
+    const validationSummary = readRecord(result?.validationSummary);
+    const patchEquivalence = readRecord(result?.patchEquivalence);
+    const finalConvergence = readRecord(result?.finalBranchConvergenceState);
     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 validationStatus = readNonEmptyString2(validationSummary?.status);
+    const patchStatus = readNonEmptyString2(patchEquivalence?.status) || (patchEquivalence?.equivalent === true ? "passed" : "");
+    const mergeStatus = result?.merged === true ? "merged" : finalConvergence?.merged === false ? "not_merged" : "";
+    const convergenceStatus = readNonEmptyString2(result?.convergenceStatus) || readNonEmptyString2(finalConvergence?.status);
+    const blockedReason = readNonEmptyString2(result?.blockedReason);
+    const nextStep = readNonEmptyString2(result?.nextStep) || readNonEmptyString2(finalConvergence?.nextStep);
+    const details = [
+      jobId ? `job_id=${jobId}` : "",
+      code ? `code=${code}` : "",
+      validationStatus ? `validation=${validationStatus}` : "",
+      patchStatus ? `patch_equivalence=${patchStatus}` : "",
+      mergeStatus ? `merge=${mergeStatus}` : "",
+      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 "";
 }
@@ -3184,7 +3232,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];
@@ -3279,6 +3328,13 @@ function injectMeshSystemMessage(components, args) {
       LOG.warn("MeshRecovery", `Failed to build recovery context: ${e?.message || e}`);
     }
   }
+  const messageText = buildMeshSystemMessage({
+    event: args.event,
+    nodeLabel: args.nodeLabel,
+    metadataEvent: args.metadataEvent,
+    recoveryContext
+  });
+  if (!messageText) return { success: false, error: "unsupported mesh event" };
   const coordinatorInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
     const instState = inst.getState();
     if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
@@ -3296,19 +3352,13 @@ function injectMeshSystemMessage(components, args) {
         ...args.metadataEvent,
         ...recoveryContext ? { recoveryContext } : {}
       },
+      coordinatorMessage: messageText,
       queuedAt: Date.now()
     })) {
       LOG.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
     }
     return { success: true, forwarded: 0 };
   }
-  const messageText = buildMeshSystemMessage({
-    event: args.event,
-    nodeLabel: args.nodeLabel,
-    metadataEvent: args.metadataEvent,
-    recoveryContext
-  });
-  if (!messageText) return { success: false, error: "unsupported mesh event" };
   for (const coord of coordinatorInstances) {
     const coordState = coord.getState();
     LOG.info("MeshEvents", `Forwarding mesh event to coordinator ${coordState.instanceId}`);
@@ -9020,9 +9070,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);
@@ -9031,16 +9083,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;
@@ -9087,15 +9141,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",
@@ -9103,7 +9159,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,
@@ -9118,13 +9174,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,
@@ -9132,7 +9188,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,
@@ -9141,11 +9197,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
@@ -19432,23 +19497,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) {
@@ -19470,10 +19540,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;
@@ -21342,6 +21413,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 = chalk;
 var chalkApi = typeof chalkModule.yellow === "function" ? chalkModule : chalkModule.default || null;
 function colorize(color, text) {
@@ -22116,7 +22228,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,
@@ -25461,8 +25573,8 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 
 // src/commands/router.ts
 init_mesh_work_queue();
-import { homedir as homedir19, tmpdir as tmpdir5 } from "os";
-import { join as pathJoin, resolve as pathResolve } from "path";
+import { homedir as homedir19 } from "os";
+import { basename as pathBasename, join as pathJoin, resolve as pathResolve } from "path";
 import * as fs11 from "fs";
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
 var CHANNEL_SERVER_URL = {
@@ -25605,6 +25717,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 ? pathBasename(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;
@@ -26275,7 +26398,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");
@@ -26362,15 +26485,9 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
       });
       return String(stdout || "");
     };
-    const verifyRemoteCommitReachable = async (remoteUrl, commit) => {
-      const probeDir = fs11.mkdtempSync(pathJoin(tmpdir5(), "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, ["cat-file", "-e", `${commit}^{commit}`]);
-      } finally {
-        fs11.rmSync(probeDir, { recursive: true, force: true });
-      }
+    const verifyRemoteMainContainsCommit = async (submodulePath, commit, branch = "main") => {
+      await runGit2(submodulePath, ["-c", "protocol.file.allow=always", "fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+      await runGit2(submodulePath, ["merge-base", "--is-ancestor", commit, `refs/remotes/origin/${branch}`]);
     };
     const treeOutput = await runGit2(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
     const gitlinks = treeOutput.split("\0").filter(Boolean).map((record) => {
@@ -26411,15 +26528,18 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
             entries.push(entry);
             continue;
           }
-          await verifyRemoteCommitReachable(remoteUrl, gitlink.commit);
+          entry.remoteMainBranch = "main";
+          await verifyRemoteMainContainsCommit(submodulePath, 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));
@@ -27394,28 +27514,51 @@ var DaemonCommandRouter = class {
     };
   }
   queueRefineJobEvent(event, handle, result) {
-    queuePendingMeshCoordinatorEvent({
+    const metadataEvent = {
+      source: "refine_mesh_node_async_job",
+      jobId: handle.jobId,
+      interactionId: handle.interactionId,
+      meshId: handle.meshId,
+      nodeId: handle.targetNodeId,
+      targetDaemonId: handle.targetDaemonId,
+      workspace: handle.workspace,
+      status: handle.status,
+      startedAt: handle.startedAt,
+      completedAt: handle.completedAt,
+      retryOfJobId: handle.retryOfJobId,
+      ...result ? { result } : {}
+    };
+    const eventPayload = {
       event,
       meshId: handle.meshId,
       nodeLabel: handle.targetNodeId,
       nodeId: handle.targetNodeId,
       workspace: handle.workspace,
-      metadataEvent: {
-        source: "refine_mesh_node_async_job",
-        jobId: handle.jobId,
-        interactionId: handle.interactionId,
-        meshId: handle.meshId,
-        nodeId: handle.targetNodeId,
-        targetDaemonId: handle.targetDaemonId,
-        workspace: handle.workspace,
-        status: handle.status,
-        startedAt: handle.startedAt,
-        completedAt: handle.completedAt,
-        retryOfJobId: handle.retryOfJobId,
-        ...result ? { result } : {}
-      },
+      metadataEvent,
       queuedAt: Date.now()
-    });
+    };
+    if (typeof this.deps.instanceManager?.getByCategory === "function") {
+      const forwarded = handleMeshForwardEvent(
+        { instanceManager: this.deps.instanceManager },
+        {
+          event,
+          meshId: handle.meshId,
+          nodeId: handle.targetNodeId,
+          workspace: handle.workspace,
+          jobId: handle.jobId,
+          interactionId: handle.interactionId,
+          status: handle.status,
+          targetDaemonId: handle.targetDaemonId,
+          startedAt: handle.startedAt,
+          completedAt: handle.completedAt,
+          retryOfJobId: handle.retryOfJobId,
+          ...result ? { result } : {}
+        }
+      );
+      if (forwarded?.success === true) return;
+      LOG.warn("Mesh", `[Refinery] Failed to forward async refine event ${event}: ${forwarded?.error || "unknown error"}`);
+    }
+    queuePendingMeshCoordinatorEvent(eventPayload);
   }
   async appendRefineJobLedger(kind, handle, result) {
     try {
@@ -27567,6 +27710,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
@@ -27579,13 +27724,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,
@@ -27593,6 +27738,8 @@ var DaemonCommandRouter = class {
             remote: entry.remote,
             remoteUrl: entry.remoteUrl,
             remoteReachable: entry.remoteReachable,
+            remoteMainBranch: entry.remoteMainBranch,
+            remoteMainReachable: entry.remoteMainReachable,
             error: entry.error
           })),
           branch,
@@ -29467,7 +29614,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,