@adhdev/daemon-core 0.9.82-rc.95 → 0.9.82-rc.97

package/dist/index.mjs

@@ -1253,7 +1253,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
    c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
    d. For the first dispatch of a new task, provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
-4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. 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\`.
+4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`.
 5. **Verify** \u2014 When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
 7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
@@ -15865,7 +15865,7 @@ var RECENT_SEND_WINDOW_MS = 1200;
 var READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25e3;
 var HERMES_CLI_STARTING_SEND_SETTLE_MS = 2e3;
 var CLI_NATIVE_HISTORY_FRESH_MS = 5 * 6e4;
-var CLI_NATIVE_TRANSCRIPT_PROVIDERS = /* @__PURE__ */ new Set(["codex-cli", "claude-cli", "hermes-cli"]);
+var CLI_NATIVE_TRANSCRIPT_PROVIDERS = /* @__PURE__ */ new Set(["codex-cli", "claude-cli", "hermes-cli", "antigravity-cli"]);
 var recentSendByTarget = /* @__PURE__ */ new Map();
 function getCurrentProviderType(h, fallback = "") {
   return h.currentSession?.providerType || h.currentProviderType || fallback;
@@ -26096,7 +26096,7 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 
 // src/commands/router.ts
 init_mesh_work_queue();
-import { homedir as homedir19 } from "os";
+import { homedir as homedir19, hostname as osHostname } 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" };
@@ -26245,12 +26245,114 @@ function buildMeshNodeDisplayLabel(node, nodeId, providerPriority) {
   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 host = readStringValue(node.machineName, node.machine_name, 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 normalizeMeshHostname(value) {
+  const hostname2 = readStringValue(value);
+  if (!hostname2) return void 0;
+  return hostname2.toLowerCase().replace(/\.$/, "");
+}
+function readMeshNodeMachineId(node) {
+  return readStringValue(
+    node.machineId,
+    node.machine_id,
+    readObjectRecord(node.machine)?.id,
+    readObjectRecord(node.machine)?.machineId,
+    readObjectRecord(node.lastProbe)?.machineId,
+    readObjectRecord(node.last_probe)?.machine_id,
+    readObjectRecord(readObjectRecord(node.lastProbe)?.machine)?.id,
+    readObjectRecord(readObjectRecord(node.lastProbe)?.machine)?.machineId,
+    readObjectRecord(readObjectRecord(node.last_probe)?.machine)?.id,
+    readObjectRecord(readObjectRecord(node.last_probe)?.machine)?.machine_id
+  );
+}
+function readMeshNodeDaemonId(node) {
+  return readStringValue(
+    node.daemonId,
+    node.daemon_id,
+    readObjectRecord(node.machine)?.daemonId,
+    readObjectRecord(node.machine)?.daemon_id,
+    readObjectRecord(node.lastProbe)?.daemonId,
+    readObjectRecord(node.last_probe)?.daemon_id,
+    readObjectRecord(readObjectRecord(node.lastProbe)?.machine)?.daemonId,
+    readObjectRecord(readObjectRecord(node.lastProbe)?.machine)?.daemon_id,
+    readObjectRecord(readObjectRecord(node.last_probe)?.machine)?.daemonId,
+    readObjectRecord(readObjectRecord(node.last_probe)?.machine)?.daemon_id
+  );
+}
+function readMeshNodeHostname(node) {
+  return readStringValue(
+    node.hostname,
+    node.host,
+    node.machineHostname,
+    node.machine_hostname,
+    readObjectRecord(node.machine)?.hostname,
+    readObjectRecord(node.machine)?.host,
+    readObjectRecord(node.lastProbe)?.hostname,
+    readObjectRecord(node.last_probe)?.hostname,
+    readObjectRecord(readObjectRecord(node.lastProbe)?.machine)?.hostname,
+    readObjectRecord(readObjectRecord(node.last_probe)?.machine)?.hostname
+  );
+}
+function readMeshNodeDisplayMachineName(node) {
+  return readStringValue(
+    node.machineName,
+    node.machine_name,
+    node.machineLabel,
+    node.machine_label,
+    node.machineNickname,
+    node.machine_nickname,
+    node.alias,
+    readObjectRecord(node.machine)?.name,
+    readObjectRecord(node.machine)?.displayName,
+    readObjectRecord(node.machine)?.display_name,
+    readObjectRecord(node.lastProbe)?.machineName,
+    readObjectRecord(node.last_probe)?.machine_name,
+    readObjectRecord(readObjectRecord(node.lastProbe)?.machine)?.name,
+    readObjectRecord(readObjectRecord(node.last_probe)?.machine)?.name,
+    readMeshNodeHostname(node)
+  );
+}
+function compactMeshIdentityEvidence(value) {
+  if (!value) return void 0;
+  return value.length > 24 ? `${value.slice(0, 12)}\u2026${value.slice(-8)}` : value;
+}
+function buildMeshNodeMachineIdentity(node, opts) {
+  const machineId = readMeshNodeMachineId(node);
+  const daemonId = readMeshNodeDaemonId(node);
+  const hostname2 = readMeshNodeHostname(node);
+  const machineName = readMeshNodeDisplayMachineName(node);
+  const coordinatorHostname = readStringValue(opts.coordinatorHostname);
+  const machineIdMatches = Boolean(opts.localMachineId && machineId && opts.localMachineId === machineId);
+  const daemonIdMatches = Boolean(opts.localDaemonId && daemonId && opts.localDaemonId === daemonId);
+  const hostnameMatches = Boolean(
+    normalizeMeshHostname(hostname2) && normalizeMeshHostname(coordinatorHostname) && normalizeMeshHostname(hostname2) === normalizeMeshHostname(coordinatorHostname)
+  );
+  const sameMachine = opts.isSelfNode === true || machineIdMatches || daemonIdMatches || hostnameMatches;
+  const evidence = [];
+  for (const [label, value] of [["machineName", machineName], ["hostname", hostname2], ["machineId", machineId], ["daemonId", daemonId]]) {
+    const compact = compactMeshIdentityEvidence(value);
+    if (compact) evidence.push(`${label}:${compact}`);
+  }
+  const locality = sameMachine ? "same_machine" : evidence.length > 0 ? "remote_known" : "remote_or_unknown";
+  const localityReason = sameMachine ? machineIdMatches ? "matched coordinator machine id" : daemonIdMatches ? "matched coordinator daemon id" : hostnameMatches ? "matched coordinator hostname" : "selected coordinator node" : evidence.length > 0 ? `known remote/other machine identity; no local coordinator match (${evidence.join(", ")})` : "no useful machine identity evidence available";
+  return {
+    daemonId,
+    machineId,
+    hostname: hostname2,
+    machineName,
+    displayName: machineName || hostname2 || daemonId || machineId,
+    coordinatorHostname,
+    sameMachine,
+    locality,
+    localityReason,
+    identityEvidence: evidence
+  };
+}
 function normalizeInlineMeshGitStatus(status, node, options) {
   const isGitRepo = readBooleanValue(status.isGitRepo);
   if (!Object.keys(status).length || isGitRepo === void 0) return void 0;
@@ -30309,6 +30411,7 @@ ${block2}`);
             return failureResult;
           }
           const directTruthUnavailableNodeIds = new Set(effectiveDirectTruth.unavailableNodeIds);
+          const coordinatorHostname = osHostname();
           const selectedCoordinatorNodeId = readStringValue(
             mesh.coordinator?.preferredNodeId,
             mesh.nodes?.[0]?.id,
@@ -30326,6 +30429,12 @@ ${block2}`);
             ) || Boolean(
               daemonId && (daemonId === localMachineId || daemonId === this.deps.statusInstanceId)
             ) || Boolean(meshRecord?.inline && nodeIndex === 0);
+            const machineIdentity = buildMeshNodeMachineIdentity(node, {
+              localMachineId,
+              localDaemonId: this.deps.statusInstanceId,
+              coordinatorHostname,
+              isSelfNode
+            });
             const status = {
               nodeId,
               machineLabel: buildMeshNodeDisplayLabel(node, nodeId, providerPriority),
@@ -30336,7 +30445,8 @@ ${block2}`);
               worktreeBranch: node.worktreeBranch,
               role: normalizeMeshDaemonRole(node.role) || (meshHost.hostNodeId && nodeId === meshHost.hostNodeId ? "host" : void 0),
               daemonId,
-              machineId: node.machineId,
+              machineId: readMeshNodeMachineId(node) || node.machineId,
+              machine: machineIdentity,
               machineStatus: node.machineStatus,
               health: "unknown",
               providers: node.providers || [],