@adhdev/daemon-core 0.9.77-rc.45 → 0.9.77-rc.47

package/dist/mesh/mesh-work-queue.d.ts

@@ -1,4 +1,8 @@
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
+export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
+export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
+export declare const ACTIVE_MESH_QUEUE_STATUSES: MeshActiveTaskStatus[];
+export declare const HISTORICAL_MESH_QUEUE_STATUSES: MeshHistoricalTaskStatus[];
 export interface MeshWorkQueueEntry {
     id: string;
     meshId: string;
@@ -76,11 +80,18 @@ export declare function requeueTask(meshId: string, taskId: string, opts?: {
  */
 export declare function updateSessionTaskStatus(meshId: string, sessionId: string, status: MeshTaskStatus): MeshWorkQueueEntry | null;
 export interface MeshWorkQueueStats {
+    total: number;
+    active: number;
+    historical: number;
     pending: number;
     assigned: number;
     completed: number;
     failed: number;
     cancelled: number;
+    /** Source-of-truth active queue counters; only pending/assigned are live work. */
+    activeCounts: Record<MeshActiveTaskStatus, number>;
+    /** Terminal ledger records kept for audit/history; never count as active work. */
+    historicalCounts: Record<MeshHistoricalTaskStatus, number>;
     activeAssignments: Array<{
         id: string;
         nodeId?: string;

package/dist/shared-types.d.ts

@@ -293,11 +293,23 @@ export interface SessionEntry {
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
         cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
         activeAssignments?: Array<{
             id: string;
             nodeId?: string;
@@ -344,11 +356,23 @@ export interface CompactSessionEntry {
     summaryMetadata?: ProviderSummaryMetadata;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
         cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
         activeAssignments?: Array<{
             id: string;
             nodeId?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.77-rc.45",
+  "version": "0.9.77-rc.47",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -1825,12 +1825,23 @@ export class DaemonCommandRouter {
                 const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
                 if (!meshId) return { success: false, error: 'meshId required' };
                 try {
-                    const { getQueue } = await import('../mesh/mesh-work-queue.js');
+                    const { getMeshQueueStats, getQueue } = await import('../mesh/mesh-work-queue.js');
                     const status = Array.isArray(args?.status)
                         ? args.status.map((s: any) => typeof s === 'string' ? s.trim() : '').filter(Boolean)
                         : undefined;
                     const queue = getQueue(meshId, { status: status as any });
-                    return { success: true, queue };
+                    const summary = getMeshQueueStats(meshId);
+                    return {
+                        success: true,
+                        queue,
+                        summary,
+                        sourceOfTruth: {
+                            kind: 'mesh_work_queue_file',
+                            activeStatuses: ['pending', 'assigned'],
+                            historicalStatuses: ['completed', 'failed', 'cancelled'],
+                            notes: 'pending/assigned are active work; completed/failed/cancelled are historical records.',
+                        },
+                    };
                 } catch (e: any) {
                     return { success: false, error: e.message };
                 }

package/src/config/config.ts

@@ -264,7 +264,8 @@ function ensureMachineId(config: ADHDevConfig): { config: ADHDevConfig; changed:
  * Get the config directory path
  */
 export function getConfigDir(): string {
-    const dir = join(homedir(), '.adhdev');
+    const override = process.env.ADHDEV_CONFIG_DIR;
+    const dir = override && override.trim() ? override.trim() : join(homedir(), '.adhdev');
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }

package/src/config/workspaces.ts

@@ -201,7 +201,7 @@ export function addWorkspaceEntry(
         }
     }
     const v = validateWorkspacePath(abs);
-    if (!v.ok) return { error: v.error };
+    if (v.ok !== true) return { error: v.error };
 
     const list = [...(config.workspaces || [])];
     if (list.some(w => path.resolve(w.path) === abs)) {

package/src/mesh/mesh-work-queue.ts

@@ -4,6 +4,11 @@ import { randomUUID } from 'crypto';
 import { getLedgerDir } from './mesh-ledger.js';
 
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
+export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
+export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
+
+export const ACTIVE_MESH_QUEUE_STATUSES: MeshActiveTaskStatus[] = ['pending', 'assigned'];
+export const HISTORICAL_MESH_QUEUE_STATUSES: MeshHistoricalTaskStatus[] = ['completed', 'failed', 'cancelled'];
 
 export interface MeshWorkQueueEntry {
     id: string;
@@ -252,11 +257,18 @@ export function updateSessionTaskStatus(
 }
 
 export interface MeshWorkQueueStats {
+    total: number;
+    active: number;
+    historical: number;
     pending: number;
     assigned: number;
     completed: number;
     failed: number;
     cancelled: number;
+    /** Source-of-truth active queue counters; only pending/assigned are live work. */
+    activeCounts: Record<MeshActiveTaskStatus, number>;
+    /** Terminal ledger records kept for audit/history; never count as active work. */
+    historicalCounts: Record<MeshHistoricalTaskStatus, number>;
     activeAssignments: Array<{
         id: string;
         nodeId?: string;
@@ -270,12 +282,29 @@ export interface MeshWorkQueueStats {
  */
 export function getMeshQueueStats(meshId: string): MeshWorkQueueStats {
     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,
+        activeCounts: {
+            pending,
+            assigned,
+        },
+        historicalCounts: {
+            completed,
+            failed,
+            cancelled,
+        },
         activeAssignments: queue
             .filter(q => q.status === 'assigned')
             .map(q => ({

package/src/shared-types.ts

@@ -390,11 +390,23 @@ export interface SessionEntry {
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
         cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
         activeAssignments?: Array<{
             id: string;
             nodeId?: string;
@@ -442,11 +454,23 @@ export interface CompactSessionEntry {
     summaryMetadata?: ProviderSummaryMetadata;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
         cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
         activeAssignments?: Array<{
             id: string;
             nodeId?: string;