@adhdev/daemon-core 0.9.77-rc.50 → 0.9.77-rc.52

package/dist/index.mjs

@@ -1207,6 +1207,7 @@ function claimNextTask(meshId, nodeId, sessionId) {
   entry.status = "assigned";
   entry.assignedNodeId = nodeId;
   entry.assignedSessionId = sessionId;
+  entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
   entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   writeQueue(meshId, queue);
   return entry;
@@ -1269,15 +1270,22 @@ function requeueTask(meshId, taskId, opts) {
 }
 function updateSessionTaskStatus(meshId, sessionId, status) {
   const queue = readQueue(meshId);
+  let bestIdx = -1;
+  let bestTime = 0;
   for (let i = queue.length - 1; i >= 0; i--) {
     if (queue[i].assignedSessionId === sessionId && queue[i].status === "assigned") {
-      queue[i].status = status;
-      queue[i].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      writeQueue(meshId, queue);
-      return queue[i];
+      const time = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
+      if (time > bestTime) {
+        bestTime = time;
+        bestIdx = i;
+      }
     }
   }
-  return null;
+  if (bestIdx === -1) return null;
+  queue[bestIdx].status = status;
+  queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeQueue(meshId, queue);
+  return queue[bestIdx];
 }
 function getMeshQueueStats(meshId) {
   const queue = readQueue(meshId);
@@ -1673,7 +1681,9 @@ var init_logger = __esm({
 // src/mesh/mesh-events.ts
 var mesh_events_exports = {};
 __export(mesh_events_exports, {
+  clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
+  getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
   triggerMeshQueue: () => triggerMeshQueue,
@@ -1682,6 +1692,12 @@ __export(mesh_events_exports, {
 function drainPendingMeshCoordinatorEvents() {
   return pendingMeshCoordinatorEvents.splice(0);
 }
+function getPendingMeshCoordinatorEvents() {
+  return pendingMeshCoordinatorEvents.slice();
+}
+function clearPendingMeshCoordinatorEvents() {
+  pendingMeshCoordinatorEvents.splice(0);
+}
 function readNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
@@ -7372,6 +7388,231 @@ function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
 
 // src/index.ts
 init_mesh_work_queue();
+
+// src/mesh/mesh-visualization.ts
+function isDirty(git) {
+  if (!git) return false;
+  return git.staged + git.modified + git.untracked + git.deleted + git.renamed > 0;
+}
+function dirtyFileCount(git) {
+  if (!git) return 0;
+  return git.staged + git.modified + git.untracked + git.deleted + git.renamed;
+}
+function detectOrphanReasons(node, defaultBranch) {
+  const reasons = [];
+  const git = node.git;
+  if (!git) {
+    reasons.push("No git status available");
+    return reasons;
+  }
+  if (!git.isGitRepo) {
+    reasons.push("Not a git repository");
+    return reasons;
+  }
+  if (git.branch === null && git.headCommit) {
+    reasons.push("Detached HEAD");
+  }
+  if (git.branch && !git.upstream) {
+    if (defaultBranch && git.branch !== defaultBranch) {
+      reasons.push(`No upstream: ${git.branch}`);
+    }
+  }
+  if (git.branch && git.upstream === null && defaultBranch && git.branch !== defaultBranch) {
+    if (!reasons.includes(`No upstream: ${git.branch}`)) {
+      reasons.push(`No upstream: ${git.branch}`);
+    }
+  }
+  if (node.error) {
+    reasons.push(`Error: ${node.error}`);
+  }
+  return reasons;
+}
+function nodeHealthPriority(health) {
+  switch (health) {
+    case "online":
+      return 0;
+    case "dirty":
+      return 1;
+    case "degraded":
+      return 2;
+    case "wrong_branch":
+      return 3;
+    case "offline":
+      return 4;
+    case "unknown":
+      return 5;
+    default:
+      return 5;
+  }
+}
+function pickDominantHealth(healths) {
+  if (healths.length === 0) return "unknown";
+  return healths.reduce(
+    (best, h) => nodeHealthPriority(h) > nodeHealthPriority(best) ? h : best
+  );
+}
+function buildMeshGraph(status) {
+  const nodes = [];
+  const edges = [];
+  const warnings = [];
+  const branchToNodeIds = /* @__PURE__ */ new Map();
+  for (const nodeStatus of status.nodes) {
+    const git = nodeStatus.git;
+    const branch = git?.branch || null;
+    const orphanReasons = detectOrphanReasons(nodeStatus, null);
+    const dirty = isDirty(git);
+    const dfc = dirtyFileCount(git);
+    let type = "worktreeNode";
+    if (orphanReasons.length > 0) {
+      type = "orphanNode";
+    }
+    const graphNode = {
+      id: nodeStatus.nodeId,
+      type,
+      label: nodeStatus.machineLabel || nodeStatus.nodeId.slice(0, 8),
+      workspace: nodeStatus.workspace,
+      branch,
+      health: nodeStatus.health,
+      ahead: git?.ahead ?? 0,
+      behind: git?.behind ?? 0,
+      dirty,
+      dirtyFiles: dfc,
+      hasConflicts: git?.hasConflicts ?? false,
+      activeSessionCount: nodeStatus.activeSessions?.length ?? 0,
+      activeSessions: nodeStatus.activeSessions ?? [],
+      providers: nodeStatus.providers ?? [],
+      isOrphan: orphanReasons.length > 0,
+      orphanReasons,
+      source: nodeStatus
+    };
+    nodes.push(graphNode);
+    if (branch) {
+      const list = branchToNodeIds.get(branch) ?? [];
+      list.push(graphNode.id);
+      branchToNodeIds.set(branch, list);
+    }
+  }
+  const branchUpstreamCounts = /* @__PURE__ */ new Map();
+  for (const n of status.nodes) {
+    const b = n.git?.branch;
+    const upstream = n.git?.upstream;
+    if (b && upstream) {
+      branchUpstreamCounts.set(b, (branchUpstreamCounts.get(b) ?? 0) + 1);
+    }
+  }
+  let inferredDefaultBranch = null;
+  let bestCount = 0;
+  for (const [b, count] of branchUpstreamCounts) {
+    if (count > bestCount) {
+      bestCount = count;
+      inferredDefaultBranch = b;
+    }
+  }
+  const defaultBranchNodeId = inferredDefaultBranch ? `__branch_${inferredDefaultBranch}` : null;
+  if (defaultBranchNodeId && inferredDefaultBranch) {
+    const branchNodes = branchToNodeIds.get(inferredDefaultBranch) ?? [];
+    const branchHealths = branchNodes.map(
+      (id) => nodes.find((n) => n.id === id).health
+    );
+    const defaultNode = {
+      id: defaultBranchNodeId,
+      type: "defaultBranchNode",
+      label: inferredDefaultBranch,
+      workspace: "",
+      branch: inferredDefaultBranch,
+      health: pickDominantHealth(branchHealths),
+      ahead: 0,
+      behind: 0,
+      dirty: false,
+      dirtyFiles: 0,
+      hasConflicts: false,
+      activeSessionCount: 0,
+      activeSessions: [],
+      providers: [],
+      isOrphan: false,
+      orphanReasons: [],
+      nextStepHint: branchNodes.length > 0 ? `${branchNodes.length} node(s) on default branch` : void 0,
+      source: {
+        nodeId: defaultBranchNodeId,
+        machineLabel: inferredDefaultBranch,
+        workspace: "",
+        health: "online",
+        providers: [],
+        activeSessions: []
+      }
+    };
+    nodes.push(defaultNode);
+    const seenBranches = /* @__PURE__ */ new Set();
+    for (const n of nodes) {
+      if (n.type === "defaultBranchNode") continue;
+      if (!n.branch) continue;
+      if (n.branch === inferredDefaultBranch) {
+        edges.push({
+          id: `${defaultBranchNodeId}--${n.id}`,
+          source: defaultBranchNodeId,
+          target: n.id,
+          type: "parentBranch",
+          label: "default"
+        });
+        continue;
+      }
+      if (seenBranches.has(n.branch)) continue;
+      seenBranches.add(n.branch);
+      edges.push({
+        id: `${defaultBranchNodeId}--branch_${n.branch}`,
+        source: defaultBranchNodeId,
+        target: n.branch,
+        type: "parentBranch",
+        label: n.branch
+      });
+    }
+  }
+  for (const [branch, ids] of branchToNodeIds) {
+    if (ids.length < 2) continue;
+    for (let i = 1; i < ids.length; i++) {
+      edges.push({
+        id: `wt_${ids[0]}--${ids[i]}`,
+        source: ids[0],
+        target: ids[i],
+        type: "worktreeLink",
+        label: branch
+      });
+    }
+  }
+  const orphanCount = nodes.filter((n) => n.isOrphan).length;
+  if (orphanCount > 0) {
+    warnings.push(`${orphanCount} orphan node(s) detected`);
+  }
+  const conflictCount = nodes.filter((n) => n.hasConflicts).length;
+  if (conflictCount > 0) {
+    warnings.push(`${conflictCount} node(s) with merge conflicts`);
+  }
+  const offlineCount = nodes.filter((n) => n.health === "offline").length;
+  if (offlineCount > 0) {
+    warnings.push(`${offlineCount} node(s) offline`);
+  }
+  const stats = {
+    totalNodes: status.nodes.length,
+    onlineNodes: status.nodes.filter((n) => n.health === "online").length,
+    dirtyNodes: nodes.filter((n) => n.dirty).length,
+    orphanNodes: orphanCount,
+    errorNodes: status.nodes.filter((n) => !!n.error).length,
+    offlineNodes: offlineCount,
+    totalActiveSessions: status.nodes.reduce((sum, n) => sum + (n.activeSessions?.length ?? 0), 0)
+  };
+  return {
+    meshId: status.meshId,
+    meshName: status.meshName,
+    repoIdentity: status.repoIdentity,
+    refreshedAt: status.refreshedAt,
+    nodes,
+    edges,
+    stats,
+    warnings
+  };
+}
+
+// src/index.ts
 init_mesh_events();
 
 // src/mesh/p2p-relay-failure.ts
@@ -9533,6 +9774,28 @@ var StatusMonitor = class {
 };
 
 // src/providers/chat-message-normalization.ts
+function extractFinalSummaryFromMessages(messages, maxChars = 500) {
+  if (!Array.isArray(messages) || messages.length === 0) return "";
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const classification = classifyChatMessageVisibility(msg);
+    if (classification.isUserFacing && (msg.role === "assistant" || msg.role === "model")) {
+      const text = flattenContent(msg.content).trim();
+      if (text) return text.slice(0, maxChars);
+    }
+  }
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const classification = classifyChatMessageVisibility(msg);
+    if (classification.isUserFacing) {
+      const text = flattenContent(msg.content).trim();
+      if (text) return text.slice(0, maxChars);
+    }
+  }
+  return "";
+}
 var BUILTIN_CHAT_MESSAGE_KINDS = ["standard", "thought", "tool", "terminal", "system"];
 var CHAT_MESSAGE_VISIBILITIES = ["user", "debug", "internal", "hidden"];
 var CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES = ["visible", "chat", "user", "debug", "internal", "hidden"];
@@ -11544,7 +11807,8 @@ var ExtensionProviderInstance = class {
           ideType: this.ideType || this.type,
           agentType: this.type,
           agentName: this.agentName || this.provider.name,
-          extensionId: this.extensionId || this.type
+          extensionId: this.extensionId || this.type,
+          finalSummary: extractFinalSummaryFromMessages(data?.messages)
         });
         this.generatingStartedAt = 0;
       }
@@ -12312,7 +12576,7 @@ var IdeProviderInstance = class {
       } else if (agentStatus === "idle" && (lastStatus === "generating" || lastStatus === "waiting_approval")) {
         const startedAt = this.generatingStartedAt.get(agentKey);
         const duration = startedAt ? Math.round((now - startedAt) / 1e3) : 0;
-        this.pushEvent({ event: "agent:generating_completed", chatTitle, duration, timestamp: now, ideType: this.type });
+        this.pushEvent({ event: "agent:generating_completed", chatTitle, duration, timestamp: now, ideType: this.type, finalSummary: extractFinalSummaryFromMessages(chatData?.messages) });
         this.generatingStartedAt.delete(agentKey);
       }
       this.lastAgentStatuses.set(agentKey, agentStatus);
@@ -17429,7 +17693,8 @@ var CliProviderInstance = class {
       event: "agent:generating_completed",
       chatTitle: pending.chatTitle,
       duration: pending.duration,
-      timestamp: pending.timestamp
+      timestamp: pending.timestamp,
+      finalSummary: extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages)
     });
     this.completedDebouncePending = null;
     this.completedDebounceTimer = null;
@@ -19177,7 +19442,7 @@ ${rawInput}` : rawInput;
         });
       } else if (newStatus === "idle" && (this.lastStatus === "generating" || this.lastStatus === "waiting_approval")) {
         const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1e3) : 0;
-        this.pushEvent({ event: "agent:generating_completed", chatTitle, duration, timestamp: now });
+        this.pushEvent({ event: "agent:generating_completed", chatTitle, duration, timestamp: now, finalSummary: extractFinalSummaryFromMessages(this.messages) });
         this.generatingStartedAt = 0;
       } else if (newStatus === "stopped") {
         this.pushEvent({ event: "agent:stopped", chatTitle, timestamp: now });
@@ -33767,6 +34032,7 @@ export {
   buildChatTailDeliverySignature,
   buildCoordinatorSystemPrompt,
   buildMachineInfo,
+  buildMeshGraph,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
   buildP2pRelayFailurePayload,
@@ -33786,6 +34052,7 @@ export {
   classifyHotChatSessionsForSubscriptionFlush,
   classifyP2pRelayFailure,
   clearDebugTrace,
+  clearPendingMeshCoordinatorEvents,
   compareGitSnapshots,
   configureDebugTraceStore,
   connectCdpManager,
@@ -33801,6 +34068,7 @@ export {
   detectAllVersions,
   detectCLIs,
   detectIDEs,
+  drainPendingMeshCoordinatorEvents,
   enqueueTask,
   ensureSessionHostReady,
   execNpmCommandSync,
@@ -33827,6 +34095,7 @@ export {
   getMeshByRepo,
   getMeshQueueStats,
   getNpmExecOptions,
+  getPendingMeshCoordinatorEvents,
   getQueue,
   getRecentActivity,
   getRecentCommands,