@adhdev/daemon-core 0.9.82-rc.460 → 0.9.82-rc.462

package/src/git/git-commands.ts

@@ -102,6 +102,14 @@ export interface GitCommandServices {
   checkoutFiles?: (params: { workspace: string; paths: string[] }) => Promise<{ checkedOut: string[] }>;
   getRemoteUrl?: (params: { workspace: string; remote?: string }) => Promise<{ remoteUrl: string; remote: string }>;
   push?: (params: { workspace: string; remote?: string; branch?: string; setUpstream?: boolean }) => Promise<GitPushResult>;
+  /**
+   * Best-effort, non-blocking source of this daemon's detected provider CLI/ACP
+   * versions (keyed by provider id) + its build version, folded onto the git_status
+   * envelope so a mesh coordinator can self-heal each node's providerVersions the
+   * same way it does platform/arch. Wired at daemon boot from the cached CLI
+   * detection snapshot; omitted (⇒ versions not reported) when unavailable.
+   */
+  getReporterProviderVersions?: () => { providerVersions?: Record<string, string>; daemonBuildVersion?: string };
 }
 
 type GitCommandFailure = {
@@ -116,7 +124,7 @@ type GitCommandSuccess =
   // node's userOverrides.platform/arch (the fields capability-tag routing reads).
   // reporterMachineNickname carries the responding daemon's config.machineNickname
   // so the coordinator can populate node.machineNickname → the friendly display label.
-  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string }
+  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string; reporterProviderVersions?: Record<string, string>; reporterDaemonBuildVersion?: string }
   | { success: true; diffSummary: GitDiffSummary }
   | { success: true; diff: GitFileDiff }
   | { success: true; snapshot: GitSnapshot }
@@ -179,7 +187,9 @@ const defaultSnapshotStore = createGitSnapshotStore({
   getDiffSummary: (workspace) => getGitDiffSummary(workspace),
 });
 
-export function createDefaultGitCommandServices(): GitCommandServices {
+export function createDefaultGitCommandServices(
+  overrides?: Pick<GitCommandServices, 'getReporterProviderVersions'>,
+): GitCommandServices {
   return {
     getStatus: ({ workspace, refreshUpstream }) => getGitRepoStatus(workspace, { refreshUpstream }),
     getDiffSummary: ({ workspace, base }) => getGitDiffSummary(workspace, base ? { baseRef: base } : {}),
@@ -199,6 +209,9 @@ export function createDefaultGitCommandServices(): GitCommandServices {
     getRemoteUrl: async ({ workspace, remote = 'origin' }) => gitGetRemoteUrl(workspace, remote),
     push: async ({ workspace, remote = 'origin', branch, setUpstream = false }) =>
       gitPush(workspace, remote, branch, setUpstream),
+    ...(overrides?.getReporterProviderVersions
+      ? { getReporterProviderVersions: overrides.getReporterProviderVersions }
+      : {}),
   };
 }
 
@@ -328,12 +341,32 @@ export async function handleGitCommand(
           return undefined;
         }
       })();
+      // Provider versions + build version ride the same self-report channel (T7
+      // visibility). Best-effort and non-blocking: the service reads a cached
+      // snapshot, so a cold cache simply omits the fields on this probe.
+      const reporterVersions = (() => {
+        try {
+          return services.getReporterProviderVersions?.() ?? {};
+        } catch {
+          return {};
+        }
+      })();
+      const reporterProviderVersions =
+        reporterVersions.providerVersions && Object.keys(reporterVersions.providerVersions).length > 0
+          ? reporterVersions.providerVersions
+          : undefined;
+      const reporterDaemonBuildVersion =
+        typeof reporterVersions.daemonBuildVersion === 'string' && reporterVersions.daemonBuildVersion.trim()
+          ? reporterVersions.daemonBuildVersion.trim()
+          : undefined;
       return {
         success: true,
         status,
         reporterPlatform: process.platform,
         reporterArch: process.arch,
         ...(reporterMachineNickname ? { reporterMachineNickname } : {}),
+        ...(reporterProviderVersions ? { reporterProviderVersions } : {}),
+        ...(reporterDaemonBuildVersion ? { reporterDaemonBuildVersion } : {}),
       };
     }
 

package/src/index.ts

@@ -295,7 +295,7 @@ export { buildMeshHostRequiredFailure, createDefaultMeshHostMetadata, isMeshHost
 // export type { MeshGraph, MeshGraphNode, MeshGraphEdge, MeshGraphNodeType, MeshGraphEdgeType } from './mesh/mesh-visualization.js';
 
 // ── Mesh Events ──
-export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
+export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
 export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
 // The coordinator-side preview surfaced from a worker's completion/status event
 // (finalSummary / workerResult.summary / lastMessagePreview). Same data the mobile

package/src/mesh/coordinator-prompt.ts

@@ -392,9 +392,27 @@ function buildNodeStatusSection(nodes: RepoMeshNodeStatus[]): string {
             ? `sessions: ${n.activeSessions.join(', ')}`
             : 'no active sessions';
         const branch = n.git?.branch ? `branch: \`${n.git.branch}\`` : '';
+        // Render each provider with its detected version when known (T7 visibility)
+        // so the coordinator can eyeball a per-node provider-version skew inline —
+        // e.g. `claude-cli@1.2.3`. Providers without a reported version render bare.
+        const providerVersions = n.providerVersions && typeof n.providerVersions === 'object'
+            ? n.providerVersions
+            : undefined;
+        const providersRendered = n.providers?.length
+            ? n.providers
+                .map((p) => {
+                    const version = providerVersions?.[p];
+                    return version ? `${p}@${version}` : p;
+                })
+                .join(', ')
+            : '';
+        const buildVersion = typeof n.daemonBuildVersion === 'string' && n.daemonBuildVersion
+            ? `build: ${n.daemonBuildVersion}`
+            : '';
         const context = [
             n.daemonId ? `daemon: \`${n.daemonId}\`` : '',
-            n.providers?.length ? `providers: ${n.providers.join(', ')}` : '',
+            providersRendered ? `providers: ${providersRendered}` : '',
+            buildVersion,
         ].filter(Boolean).join(' | ');
         lines.push(`- ${healthIcon} **${n.machineLabel}** (nodeId: \`${n.nodeId}\`)`);
         lines.push(`  workspace: \`${n.workspace}\`${context ? ` | ${context}` : ''} | ${branch} | ${sessions}`);

package/src/mesh/mesh-event-forwarding.ts

@@ -7,7 +7,7 @@ import type { SessionRecoveryContext } from './mesh-ledger.js';
 import { updateSessionTaskStatus, enqueueTask, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents, getQueue } from './mesh-work-queue.js';
 import { markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompletionConflict } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, type PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
+import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, readV2EnvelopeFromWire, type PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
 import { resolveMeshHostStatus } from './mesh-host-ownership.js';
@@ -681,6 +681,13 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     nodeLabel: string;
     event: string;
     metadataEvent: Record<string, unknown>;
+    // T4 (B3b): v2 envelope restored from a remote (P2P) relay's flat payload. Only the
+    // relay path (handleMeshForwardEvent) sets it; the in-process forward path leaves it
+    // undefined and the local emit stamp applies as usual. When present with a preserved
+    // eventId, it is spread onto the re-queued pending event so stampPendingEventV2's
+    // already-stamped short-circuit keeps the ORIGINAL eventId (cross-machine idempotency).
+    v2Envelope?: Partial<Pick<PendingMeshCoordinatorEvent,
+        'protocolVersion' | 'eventId' | 'scope' | 'dispatchedBy' | 'intendedFor'>>;
 }) {
     const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
     const eventNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
@@ -1363,6 +1370,12 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         // Top-level session anchor for the local PHASE 2 strict-match on the coordinator
         // daemon. Absent → daemon-level broadcast (legacy / single-coordinator path).
         ...(workerCoordinatorSessionId ? { targetCoordinatorSessionId: workerCoordinatorSessionId } : {}),
+        // T4 (B3b): restore the v2 envelope from the remote relay so the re-queue keeps the
+        // ORIGINAL eventId. Spread LAST so its authoritative eventId/scope/identity win over
+        // any default. queuePendingMeshCoordinatorEvent → stampPendingEventV2 then no-ops
+        // (already-stamped short-circuit) instead of minting a fresh eventId. Empty object
+        // for a v1 relay → unchanged v1 emit-stamp path (version-skew safe).
+        ...(args.v2Envelope ?? {}),
     };
     if (queuePendingMeshCoordinatorEvent(pendingEvent)) {
         LOG.info('MeshEvents', `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ''}${workerCoordinatorSessionId ? `, coordinator session ${workerCoordinatorSessionId}` : ''})`);
@@ -1518,6 +1531,11 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
         nodeLabel,
         event: eventName,
         metadataEvent: buildRelayMetadataEvent(payload),
+        // T4 (B3b): restore the v2 envelope carried at the top level of the relayed flat
+        // payload (buildForwardPayloadFromPending → serializeV2EnvelopeToWire) so the
+        // re-queue preserves the original eventId (idempotency) and unicast routing rather
+        // than re-stamping a fresh v1/broadcast event. Empty for a v1 relay (version-skew safe).
+        v2Envelope: readV2EnvelopeFromWire(payload),
     });
 }