@adhdev/daemon-standalone 0.9.77-rc.45 → 0.9.77-rc.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-standalone",
-  "version": "0.9.77-rc.45",
+  "version": "0.9.77-rc.46",
   "description": "ADHDev standalone daemon — embedded HTTP/WS server for local dashboard",
   "main": "dist/index.js",
   "bin": {

package/vendor/mcp-server/index.js

@@ -25503,7 +25503,8 @@ function ensureMachineId(config2) {
   };
 }
 function getConfigDir() {
-  const dir = (0, import_path.join)((0, import_os2.homedir)(), ".adhdev");
+  const override = process.env.ADHDEV_CONFIG_DIR;
+  const dir = override && override.trim() ? override.trim() : (0, import_path.join)((0, import_os2.homedir)(), ".adhdev");
   if (!(0, import_fs4.existsSync)(dir)) {
     (0, import_fs4.mkdirSync)(dir, { recursive: true });
   }
@@ -26183,12 +26184,20 @@ function updateSessionTaskStatus(meshId, sessionId, status) {
 }
 function getMeshQueueStats(meshId) {
   const queue = readQueue(meshId);
+  const pending = queue.filter((q) => q.status === "pending").length;
+  const assigned = queue.filter((q) => q.status === "assigned").length;
+  const completed = queue.filter((q) => q.status === "completed").length;
+  const failed = queue.filter((q) => q.status === "failed").length;
+  const cancelled = queue.filter((q) => q.status === "cancelled").length;
   return {
-    pending: queue.filter((q) => q.status === "pending").length,
-    assigned: queue.filter((q) => q.status === "assigned").length,
-    completed: queue.filter((q) => q.status === "completed").length,
-    failed: queue.filter((q) => q.status === "failed").length,
-    cancelled: queue.filter((q) => q.status === "cancelled").length,
+    total: queue.length,
+    active: pending + assigned,
+    historical: completed + failed + cancelled,
+    pending,
+    assigned,
+    completed,
+    failed,
+    cancelled,
     activeAssignments: queue.filter((q) => q.status === "assigned").map((q) => ({
       id: q.id,
       nodeId: q.assignedNodeId,
@@ -28796,7 +28805,7 @@ function addWorkspaceEntry(config2, rawPath, label, options) {
     }
   }
   const v = validateWorkspacePath(abs);
-  if (!v.ok) return { error: v.error };
+  if (v.ok !== true) return { error: v.error };
   const list = [...config2.workspaces || []];
   if (list.some((w) => path5.resolve(w.path) === abs)) {
     return { error: "Workspace already in list" };
@@ -58570,6 +58579,8 @@ function readString(value) {
 }
 var DUPLICATE_DISPATCH_WINDOW_MS = 6e4;
 var STALE_ASSIGNED_QUEUE_MS = 30 * 6e4;
+var ACTIVE_QUEUE_STATUSES = /* @__PURE__ */ new Set(["pending", "assigned"]);
+var HISTORICAL_QUEUE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 async function refreshMeshFromDaemon(ctx) {
   if (!(ctx.transport instanceof IpcTransport)) return;
   try {
@@ -58695,30 +58706,126 @@ function buildMissingNodeReadChatRecovery(ctx, args) {
     ]
   };
 }
-function annotateQueueStaleness(queue) {
+function readSessionRecordId(session) {
+  return readString(session?.id) || readString(session?.sessionId) || readString(session?.session_id) || readString(session?.runtimeSessionId) || readString(session?.runtime_session_id) || readString(session?.instanceId) || readString(session?.instance_id);
+}
+function addSessionRecord(target, session) {
+  if (!session || typeof session !== "object" || isTerminalSessionRecord(session)) return;
+  const sessionId = readSessionRecordId(session);
+  if (sessionId) target.add(sessionId);
+}
+function collectNodeSessionIds(node) {
+  const sessions = /* @__PURE__ */ new Set();
+  const sessionArrays = [
+    node?.sessions,
+    node?.activeSessions,
+    node?.active_sessions,
+    node?.lastProbe?.sessions,
+    node?.last_probe?.sessions,
+    node?.lastProbe?.status?.sessions,
+    node?.last_probe?.status?.sessions
+  ];
+  for (const value of sessionArrays) {
+    if (Array.isArray(value)) value.forEach((session) => addSessionRecord(sessions, session));
+  }
+  const sessionRecords = [
+    node?.activeSession,
+    node?.active_session,
+    node?.currentSession,
+    node?.current_session,
+    node?.runtimeSession,
+    node?.runtime_session,
+    node?.session,
+    node?.lastProbe?.activeSession,
+    node?.last_probe?.active_session,
+    node?.lastProbe?.currentSession,
+    node?.last_probe?.current_session,
+    node?.lastProbe?.session,
+    node?.last_probe?.session
+  ];
+  sessionRecords.forEach((session) => addSessionRecord(sessions, session));
+  return sessions;
+}
+function buildQueueLivenessIndex(mesh) {
+  const nodeIds = /* @__PURE__ */ new Set();
+  const nodeSessionIds = /* @__PURE__ */ new Map();
+  for (const node of Array.isArray(mesh?.nodes) ? mesh.nodes : []) {
+    const nodeId = readString(node.id) || readString(node.nodeId) || readString(node.node_id);
+    if (!nodeId) continue;
+    nodeIds.add(nodeId);
+    const sessions = collectNodeSessionIds(node);
+    if (sessions.size > 0) nodeSessionIds.set(nodeId, sessions);
+  }
+  return { nodeIds, nodeSessionIds };
+}
+function queueAssignmentStaleReason(task, liveness) {
+  if (task?.status !== "assigned") return void 0;
+  const nodeId = readString(task.assignedNodeId) || readString(task.nodeId) || readString(task.node_id) || readString(task.targetNodeId);
+  const sessionId = readString(task.assignedSessionId) || readString(task.sessionId) || readString(task.session_id) || readString(task.targetSessionId);
+  if (nodeId && liveness.nodeIds.size > 0 && !liveness.nodeIds.has(nodeId)) {
+    return "assigned node is not present in the current mesh snapshot";
+  }
+  if (nodeId && sessionId && liveness.nodeSessionIds.has(nodeId) && !liveness.nodeSessionIds.get(nodeId).has(sessionId)) {
+    return "assigned session is not live on the assigned node";
+  }
+  const updatedAt = new Date(task.updatedAt).getTime();
+  const ageMs = Number.isFinite(updatedAt) ? Date.now() - updatedAt : null;
+  if (!nodeId && ageMs !== null && ageMs >= STALE_ASSIGNED_QUEUE_MS) {
+    return "assigned task has no assigned node metadata";
+  }
+  return void 0;
+}
+function buildQueueStatusSummary(queue) {
+  const counts = { pending: 0, assigned: 0, completed: 0, failed: 0, cancelled: 0 };
+  for (const task of queue) {
+    const status = typeof task?.status === "string" ? task.status : void 0;
+    if (status && Object.prototype.hasOwnProperty.call(counts, status)) {
+      counts[status] += 1;
+    }
+  }
+  return {
+    totalCount: queue.length,
+    activeCount: counts.pending + counts.assigned,
+    historicalCount: counts.completed + counts.failed + counts.cancelled,
+    counts,
+    activeCounts: {
+      pending: counts.pending,
+      assigned: counts.assigned
+    },
+    historicalCounts: {
+      completed: counts.completed,
+      failed: counts.failed,
+      cancelled: counts.cancelled
+    }
+  };
+}
+function annotateQueueStaleness(queue, mesh) {
+  const liveness = buildQueueLivenessIndex(mesh);
   const now = Date.now();
   return queue.map((task) => {
     const taskStatus = typeof task?.status === "string" ? task.status : void 0;
     const annotated = {
       ...task,
       taskStatus,
+      isActive: taskStatus ? ACTIVE_QUEUE_STATUSES.has(taskStatus) : false,
+      isHistorical: taskStatus ? HISTORICAL_QUEUE_STATUSES.has(taskStatus) : false,
       dispatchedAt: task?.createdAt,
       ...taskStatus === "assigned" ? { activeTaskId: task.id } : {},
       ...taskStatus === "completed" || taskStatus === "failed" ? {
-        isHistorical: true,
         completedAt: task.updatedAt
       } : {}
     };
     if (taskStatus !== "assigned") return annotated;
     const updatedAt = new Date(task.updatedAt).getTime();
     const ageMs = Number.isFinite(updatedAt) ? now - updatedAt : null;
-    if (ageMs === null || ageMs < STALE_ASSIGNED_QUEUE_MS) return annotated;
+    const staleReason = queueAssignmentStaleReason(task, liveness);
+    if (!staleReason) return annotated;
     return {
       ...annotated,
       stale: true,
       staleAssigned: true,
-      staleReason: "assigned task has not reached a terminal state within 30 minutes",
-      assignedAgeMs: ageMs
+      staleReason,
+      ...ageMs !== null ? { assignedAgeMs: ageMs } : {}
     };
   });
 }
@@ -59649,11 +59756,17 @@ async function meshEnqueueTask(ctx, args) {
 }
 async function meshViewQueue(ctx, args) {
   try {
-    const queue = annotateQueueStaleness(getQueue(ctx.mesh.id, { status: args.status }));
+    const queue = annotateQueueStaleness(getQueue(ctx.mesh.id, { status: args.status }), ctx.mesh);
     const staleAssignedTasks = queue.filter((task) => task?.status === "assigned" && task?.staleAssigned);
+    const summary = buildQueueStatusSummary(queue);
     return JSON.stringify({
       success: true,
       queue,
+      summary,
+      activeCounts: summary.activeCounts,
+      historicalCounts: summary.historicalCounts,
+      activeCount: summary.activeCount,
+      historicalCount: summary.historicalCount,
       staleAssignedTasks,
       staleAssignedCount: staleAssignedTasks.length,
       // Back-compat alias for callers already reading the first hardening payload.