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

package/dist/index.js

@@ -23254,25 +23254,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");
@@ -23313,7 +23330,7 @@ ${rules.join("\n")}`;
 - **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;
@@ -23362,7 +23379,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.
 
@@ -25201,23 +25218,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 error48 = 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})` : ""}${error48 ? `: ${error48}` : "."} 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})` : ""}${error48 ? `: ${error48}` : "."}`,
+          nextStep ? `Next step: ${nextStep}` : "Review the terminal refine event/ledger before retrying."
+        ];
+        return parts.join("\n");
       }
       return "";
     }
@@ -25339,7 +25387,8 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           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];
@@ -25434,6 +25483,13 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           LOG2.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;
@@ -25451,19 +25507,13 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
             ...args.metadataEvent,
             ...recoveryContext ? { recoveryContext } : {}
           },
+          coordinatorMessage: messageText,
           queuedAt: Date.now()
         })) {
           LOG2.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();
         LOG2.info("MeshEvents", `Forwarding mesh event to coordinator ${coordState.instanceId}`);
@@ -31389,9 +31439,11 @@ ${lastSnapshot}`;
       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);
@@ -31400,16 +31452,18 @@ ${lastSnapshot}`;
         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;
@@ -31456,15 +31510,17 @@ ${lastSnapshot}`;
         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",
@@ -31472,7 +31528,7 @@ ${lastSnapshot}`;
           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,
@@ -31487,13 +31543,13 @@ ${lastSnapshot}`;
         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 record2 = {
           taskId,
           source: "direct",
           status,
@@ -31501,7 +31557,7 @@ ${lastSnapshot}`;
           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,
@@ -31510,11 +31566,20 @@ ${lastSnapshot}`;
           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(record2);
+          continue;
+        }
+        records.push(record2);
       }
       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 };
     }
     init_mesh_host_ownership();
     init_mesh_events();
@@ -41699,23 +41764,28 @@ ${effect.notification.body || ""}`.trim();
         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 partial2 = typeof this.adapter.getPartialResponse === "function" ? this.adapter.getPartialResponse() : "";
-        if (typeof partial2 === "string" && partial2.trim()) return "partial_response_pending";
+        if (typeof partial2 === "string" && partial2.trim()) return { reason: "partial_response_pending", terminal: true };
         let parsed;
         try {
           parsed = this.adapter.getScriptParsedStatus();
         } catch (error48) {
-          return `parse_error:${error48?.message || String(error48)}`;
+          return { reason: `parse_error:${error48?.message || String(error48)}` };
         }
         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) {
@@ -41737,10 +41807,11 @@ ${effect.notification.body || ""}`.trim();
           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) {
               LOG2.info("CLI", `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
               pending.loggedBlockReason = blockReason;
@@ -43596,6 +43667,47 @@ ${rawInput}` : rawInput;
     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 partial2 = typeof adapter?.getPartialResponse === "function" ? adapter.getPartialResponse() : "";
+        if (typeof partial2 === "string" && partial2.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) {
@@ -44370,7 +44482,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,
@@ -47831,6 +47943,17 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       }).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;
@@ -48501,7 +48624,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     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");
@@ -48588,15 +48711,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           });
           return String(stdout || "");
         };
-        const verifyRemoteCommitReachable = async (remoteUrl, commit) => {
-          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, ["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((record2) => {
@@ -48637,15 +48754,18 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 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));
@@ -49620,28 +49740,51 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         };
       }
       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;
+          LOG2.warn("Mesh", `[Refinery] Failed to forward async refine event ${event}: ${forwarded?.error || "unknown error"}`);
+        }
+        queuePendingMeshCoordinatorEvent(eventPayload);
       }
       async appendRefineJobLedger(kind, handle, result) {
         try {
@@ -49793,6 +49936,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               remote: entry.remote,
               remoteUrl: entry.remoteUrl,
               remoteReachable: entry.remoteReachable,
+              remoteMainBranch: entry.remoteMainBranch,
+              remoteMainReachable: entry.remoteMainReachable,
               error: entry.error
             })),
             error: submoduleReachability.error
@@ -49805,13 +49950,13 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               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,
@@ -49819,6 +49964,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 remote: entry.remote,
                 remoteUrl: entry.remoteUrl,
                 remoteReachable: entry.remoteReachable,
+                remoteMainBranch: entry.remoteMainBranch,
+                remoteMainReachable: entry.remoteMainReachable,
                 error: entry.error
               })),
               branch,
@@ -51693,7 +51840,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,