@adhdev/daemon-core 0.5.3 → 0.5.5

package/src/providers/ide-provider-instance.ts

@@ -274,6 +274,17 @@ export class IdeProviderInstance implements ProviderInstance {
                 msg.receivedAt = prevByHash.get(h) || now;
             }
 
+            // Filter messages by provider settings (showThinking, showToolCalls, showTerminal)
+            if (raw.messages?.length > 0) {
+                const hiddenKinds = new Set<string>();
+                if (this.settings.showThinking === false) hiddenKinds.add('thought');
+                if (this.settings.showToolCalls === false) hiddenKinds.add('tool');
+                if (this.settings.showTerminal === false) hiddenKinds.add('terminal');
+                if (hiddenKinds.size > 0) {
+                    raw.messages = raw.messages.filter((m: any) => !hiddenKinds.has(m.kind));
+                }
+            }
+
             this.cachedChat = { ...raw, activeModal };
             this.detectAgentTransitions(raw, now);
 

package/src/status/reporter.ts

@@ -8,6 +8,9 @@
 import * as os from 'os';
 import * as path from 'path';
 import { loadConfig } from '../config/config.js';
+import { getWorkspaceState } from '../config/workspaces.js';
+import { getHostMemorySnapshot } from '../system/host-memory.js';
+import { getWorkspaceActivity } from '../config/workspace-activity.js';
 import { LOG } from '../logging/logger.js';
 
 // ─── Daemon dependency interface ──────────────────────
@@ -95,6 +98,11 @@ export class DaemonStatusReporter {
  // (agent-stream polling backward compat)
     updateAgentStreams(_ideType: string, _streams: any[]): void { /* Managed by Instance itself */ }
 
+    /** Reset P2P dedup hash — forces next send to transmit even if content unchanged */
+    resetP2PHash(): void {
+        this.lastP2PStatusHash = '';
+    }
+
  // ─── Core ────────────────────────────────────────
 
     private ts(): string {
@@ -197,17 +205,26 @@ export class DaemonStatusReporter {
 
 
 
+        const cfg = loadConfig();
+        const wsState = getWorkspaceState(cfg);
+        const memSnap = getHostMemorySnapshot();
+
  // ═══ Assemble payload (P2P — required data only) ═══
         const payload: Record<string, any> = {
             daemonMode: true,
-            machineNickname: loadConfig().machineNickname || null,
+            machineNickname: cfg.machineNickname || null,
+            workspaces: wsState.workspaces,
+            defaultWorkspaceId: wsState.defaultWorkspaceId,
+            defaultWorkspacePath: wsState.defaultWorkspacePath,
+            workspaceActivity: getWorkspaceActivity(cfg, 15),
             machine: {
                 hostname: os.hostname(),
                 platform: os.platform(),
                 arch: os.arch(),
                 cpus: os.cpus().length,
-                totalMem: os.totalmem(),
-                freeMem: os.freemem(),
+                totalMem: memSnap.totalMem,
+                freeMem: memSnap.freeMem,
+                availableMem: memSnap.availableMem,
                 loadavg: os.loadavg(),
                 uptime: os.uptime(),
             },
@@ -243,6 +260,8 @@ export class DaemonStatusReporter {
             const wsPayload = {
                 daemonMode: true,
                 machineNickname: payload.machineNickname,
+                defaultWorkspaceId: wsState.defaultWorkspaceId,
+                workspaceCount: (wsState.workspaces || []).length,
  // managedIdes: server only saves id, type, cdpConnected
                 managedIdes: managedIdes.map(ide => ({
                     ideType: ide.ideType,
@@ -271,7 +290,7 @@ export class DaemonStatusReporter {
     private sendP2PPayload(payload: Record<string, any>): boolean {
         const { timestamp: _ts, system: _sys, ...hashTarget } = payload;
         if (hashTarget.machine) {
-            const { freeMem: _f, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine as any;
+            const { freeMem: _f, availableMem: _a, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine as any;
             hashTarget.machine = stableMachine;
         }
         const h = this.simpleHash(JSON.stringify(hashTarget));

package/src/system/host-memory.ts

@@ -0,0 +1,65 @@
+/**
+ * Host memory metrics — macOS-aware "available" memory.
+ *
+ * Node's os.freemem() on darwin reports only the tiny truly-free pool; most RAM
+ * sits in inactive/file-backed cache that the OS can reclaim. Dashboard "used %"
+ * based on (total - freemem) looks ~99% almost always — misleading.
+ *
+ * On macOS we parse `vm_stat` and approximate available bytes as:
+ *   (free + inactive + speculative + purgeable [+ file_backed]) × page size
+ * (aligned with common Activity Monitor–style interpretations.)
+ */
+
+import * as os from 'os';
+import { execSync } from 'child_process';
+
+export interface HostMemorySnapshot {
+    totalMem: number;
+    /** Raw kernel "free" — small on macOS; kept for debugging / API compat */
+    freeMem: number;
+    /** Use this for UI "used %" — on darwin from vm_stat; else equals freeMem */
+    availableMem: number;
+}
+
+function parseDarwinAvailableBytes(totalMem: number): number | null {
+    if (os.platform() !== 'darwin') return null;
+    try {
+        const out = execSync('vm_stat', {
+            encoding: 'utf-8',
+            timeout: 4000,
+            maxBuffer: 256 * 1024,
+        });
+        const pageSizeMatch = out.match(/page size of (\d+)\s*bytes/i);
+        const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 4096;
+
+        const counts: Record<string, number> = {};
+        for (const line of out.split('\n')) {
+            const m = line.match(/^\s*Pages\s+([^:]+):\s+([\d,]+)\s*\.?/);
+            if (!m) continue;
+            const key = m[1].trim().toLowerCase().replace(/\s+/g, '_');
+            const n = parseInt(m[2].replace(/,/g, ''), 10);
+            if (!Number.isNaN(n)) counts[key] = n;
+        }
+
+        const free = counts['free'] ?? 0;
+        const inactive = counts['inactive'] ?? 0;
+        const speculative = counts['speculative'] ?? 0;
+        const purgeable = counts['purgeable'] ?? 0;
+        const fileBacked = counts['file_backed'] ?? 0;
+
+        const availPages = free + inactive + speculative + purgeable + fileBacked;
+        const bytes = availPages * pageSize;
+        if (!Number.isFinite(bytes) || bytes < 0) return null;
+        return Math.min(bytes, totalMem);
+    } catch {
+        return null;
+    }
+}
+
+export function getHostMemorySnapshot(): HostMemorySnapshot {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const darwinAvail = parseDarwinAvailableBytes(totalMem);
+    const availableMem = darwinAvail != null ? darwinAvail : freeMem;
+    return { totalMem, freeMem, availableMem };
+}

package/src/types.ts

@@ -43,7 +43,7 @@ export interface IdeEntry {
   agentStreams?: AgentStreamEntry[];
  /** Extension agents monitored via CDP */
   extensions?: ExtensionInfo[];
- /** Workspace folders */
+ /** IDE-reported workspace roots (name + path) */
   workspaceFolders?: { name: string; path: string }[];
  /** Active file path */
   activeFile?: string | null;
@@ -150,6 +150,8 @@ export interface SystemInfo {
   cpus: number;
   totalMem: number;
   freeMem: number;
+  /** macOS: reclaimable-inclusive; prefer for UI used% (see host-memory.ts) */
+  availableMem?: number;
   loadavg: number[];
   uptime: number;
   arch: string;
@@ -183,6 +185,11 @@ export interface StatusResponse {
   detectedIdes: DetectedIde[];
   availableProviders: ProviderInfo[];
   system: SystemInfo;
+  /** Saved workspaces (standalone WS / HTTP status) */
+  workspaces?: { id: string; path: string; label?: string; addedAt: number }[];
+  defaultWorkspaceId?: string | null;
+  defaultWorkspacePath?: string | null;
+  workspaceActivity?: { path: string; lastUsedAt: number; kind?: string; agentType?: string }[];
 }
 
 /** Agent stream entry within an IDE */