5.7.0

changelog.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 2025-08-31 - 5.7.0 - feat(cli)
+Add 'stats' CLI command and daemon stats aggregation; fix process manager & wrapper state handling
+
+- Add new 'stats' CLI command to show daemon + process statistics (memory, CPU, uptime, logs in memory, paths, configs) and include it in the default help output
+- Implement daemon-side aggregation for logs-in-memory, per-process log counts/bytes, and expose tspmDir/socket/pidFile and config counts in daemon:status
+- Enhance startById handler to detect already-running monitors and return current status/pid instead of attempting to restart
+- Improve ProcessManager start/restart/stop behavior: if an existing monitor exists but is not running, restart it; ensure PID and status are updated consistently (clear PID on stop)
+- Fix ProcessWrapper lifecycle handling: clear internal process reference on exit, improve isRunning() and getPid() semantics to reflect actual runtime state
+- Update IPC types to include optional metadata fields (paths, configs, logsInMemory) in DaemonStatusResponse
+
+## 2025-08-31 - 5.6.2 - fix(processmanager)
+Improve process lifecycle handling and cleanup in daemon, monitors and wrappers
+
+- StartAll: when a monitor exists but is not running, restart it instead of skipping — ensures saved processes are reliably brought online.
+- ProcessMonitor.stop: cancel any pending restart timers to prevent stray restarts after explicit stop.
+- ProcessWrapper: add killProcessTree helper and use it for graceful (SIGTERM) and force (SIGKILL) shutdowns to reliably signal child processes.
+- Daemon stopAll: yield briefly after stopping processes and inspect monitors (not only processInfo) to accurately report stopped vs failed processes.
+
+## 2025-08-31 - 5.6.1 - fix(daemon)
+Ensure robust process shutdown and improve logs/subscriber diagnostics
+
+- Make ProcessWrapper.stop asynchronous and awaitable to avoid race conditions when stopping processes
+- Signal entire process groups on POSIX (kill by negative PID) and fall back to per-PID signalling; escalate to SIGKILL after a timeout
+- Await processWrapper.stop() from ProcessMonitor when enforcing memory limits or handling exits/errors to ensure child processes are cleaned up
+- Add logs:subscribers IPC endpoint and corresponding types to inspect current subscribers for a process log topic
+- Add optional CLI debug output in logs command (enabled via TSPM_DEBUG=true) to print subscriber counts and details
+- Support passing request.lines to getLogs handler in daemon to limit returned log entries
+
+## 2025-08-30 - 5.6.0 - feat(processmonitor)
+Add CPU monitoring and display CPU in process list
+
+- CLI: show a CPU column in the `tspm list` output (adds formatting and placeholder name display)
+- Daemon: ProcessMonitor now collects CPU usage for the process group in addition to memory
+- Daemon: ProcessMonitor exposes getLastCpuUsage() and ProcessManager syncs CPU values into IProcessInfo
+- Non-breaking: UI and internal stats enriched to surface CPU metrics for processes
+
 ## 2025-08-30 - 5.5.0 - feat(logs)
 Improve logs streaming and backlog delivery; add CLI filters and ndjson output
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tspm",
-  "version": "5.5.0",
+  "version": "5.7.0",
   "private": false,
   "description": "a no fuzz process manager",
   "main": "dist_ts/index.js",

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tspm',
-  version: '5.5.0',
+  version: '5.7.0',
   description: 'a no fuzz process manager'
 }

ts/cli/commands/default.ts

@@ -39,6 +39,7 @@ export function registerDefaultCommand(smartcli: plugins.smartcli.Smartcli) {
       );
       console.log('  daemon stop              Stop the daemon');
       console.log('  daemon status            Show daemon status');
+      console.log('  stats                    Show daemon + process stats');
       console.log(
         '\nUse tspm [command] --help for more information about a command.',
       );

ts/cli/commands/process/list.ts

@@ -20,13 +20,13 @@ export function registerListCommand(smartcli: plugins.smartcli.Smartcli) {
 
       console.log('Process List:');
       console.log(
-        '┌─────────┬─────────────┬───────────┬───────────┬──────────┬──────────┐',
+        '┌─────────┬─────────────┬───────────┬───────────┬──────────┬──────────┬─────────┐',
       );
       console.log(
-        '│ ID      │ Name        │ Status    │ PID       │ Memory   │ Restarts │',
+        '│ ID      │ Name        │ Status    │ PID       │ Memory   │ CPU      │ Restarts │',
       );
       console.log(
-        '├─────────┼─────────────┼───────────┼───────────┼──────────┼──────────┤',
+        '├─────────┼─────────────┼───────────┼───────────┼──────────┼──────────┼──────────┤',
       );
 
       for (const proc of processes) {
@@ -38,13 +38,18 @@ export function registerListCommand(smartcli: plugins.smartcli.Smartcli) {
               : '\x1b[33m';
         const resetColor = '\x1b[0m';
 
+        const cpuStr = typeof proc.cpu === 'number' && isFinite(proc.cpu)
+          ? `${proc.cpu.toFixed(1)}%`
+          : '-';
+        // Name is not part of IProcessInfo; show ID as placeholder for now
+        const nameDisplay = String(proc.id);
         console.log(
-          `│ ${pad(String(proc.id), 7)} │ ${pad(String(proc.id), 11)} │ ${statusColor}${pad(proc.status, 9)}${resetColor} │ ${pad((proc.pid || '-').toString(), 9)} │ ${pad(formatMemory(proc.memory), 8)} │ ${pad(proc.restarts.toString(), 8)} │`,
+          `│ ${pad(String(proc.id), 7)} │ ${pad(nameDisplay, 11)} │ ${statusColor}${pad(proc.status, 9)}${resetColor} │ ${pad((proc.pid || '-').toString(), 9)} │ ${pad(formatMemory(proc.memory), 8)} │ ${pad(cpuStr, 8)} │ ${pad(proc.restarts.toString(), 8)} │`,
         );
       }
 
       console.log(
-        '└─────────┴─────────────┴───────────┴───────────┴──────────┴──────────┘',
+        '└─────────┴─────────────┴───────────┴───────────┴──────────┴──────────┴──────────┘',
       );
     },
     { actionLabel: 'list processes' },

ts/cli/commands/process/logs.ts

@@ -144,6 +144,13 @@ export function registerLogsCommand(smartcli: plugins.smartcli.Smartcli) {
 
       await withStreamingLifecycle(
         async () => {
+          // Optional: debug subscribers if requested via env (hidden)
+          if (process.env.TSPM_DEBUG === 'true') {
+            try {
+              const subInfo = await tspmIpcClient.request('logs:subscribers' as any, { id });
+              console.log(`[DEBUG] Subscribers for logs.${id}: ${subInfo.count} (${(subInfo.subscribers||[]).join(',')})`);
+            } catch {}
+          }
           await tspmIpcClient.subscribe(id, (log: any) => {
             // Reset sequence if runId changed (e.g., process restarted)
             if (log.runId && log.runId !== lastRunId) {

ts/cli/commands/stats.ts

@@ -0,0 +1,66 @@
+import * as plugins from '../plugins.js';
+import { tspmIpcClient } from '../../client/tspm.ipcclient.js';
+import type { CliArguments } from '../types.js';
+import { registerIpcCommand } from '../registration/index.js';
+import { pad } from '../helpers/formatting.js';
+import { formatMemory } from '../helpers/memory.js';
+
+export function registerStatsCommand(smartcli: plugins.smartcli.Smartcli) {
+  registerIpcCommand(
+    smartcli,
+    'stats',
+    async (_argvArg: CliArguments) => {
+      // Daemon status
+      const status = await tspmIpcClient.request('daemon:status', {});
+
+      console.log('TSPM Daemon:');
+      console.log('─'.repeat(60));
+      console.log(`Version:      ${status.version || 'unknown'}`);
+      console.log(`PID:          ${status.pid}`);
+      console.log(`Uptime:       ${Math.floor((status.uptime || 0) / 1000)}s`);
+      console.log(`Processes:    ${status.processCount}`);
+      if (typeof status.memoryUsage === 'number') {
+        console.log(`Memory:       ${formatMemory(status.memoryUsage)}`);
+      }
+      if (typeof status.cpuUsage === 'number') {
+        console.log(`CPU (user):   ${status.cpuUsage.toFixed(3)}s`);
+      }
+      if ((status as any).paths) {
+        const pathsInfo = (status as any).paths as { tspmDir?: string; socketPath?: string; pidFile?: string };
+        console.log(`tspmDir:      ${pathsInfo.tspmDir || '-'}`);
+        console.log(`Socket:       ${pathsInfo.socketPath || '-'}`);
+        console.log(`PID File:     ${pathsInfo.pidFile || '-'}`);
+      }
+      if ((status as any).configs) {
+        const cfg = (status as any).configs as { processConfigs?: number };
+        console.log(`Configs:      ${cfg.processConfigs ?? 0}`);
+      }
+      if ((status as any).logsInMemory) {
+        const lm = (status as any).logsInMemory as { totalCount: number; totalBytes: number };
+        console.log(`Logs (mem):   ${lm.totalCount} entries, ${formatMemory(lm.totalBytes)}`);
+      }
+      console.log('');
+
+      // Process list (reuse list view with CPU column)
+      const response = await tspmIpcClient.request('list', {});
+      const processes = response.processes;
+      console.log('Process List:');
+      console.log('┌─────────┬─────────────┬───────────┬───────────┬──────────┬──────────┬─────────┐');
+      console.log('│ ID      │ Name        │ Status    │ PID       │ Memory   │ CPU      │ Restarts │');
+      console.log('├─────────┼─────────────┼───────────┼───────────┼──────────┼──────────┼──────────┤');
+      for (const proc of processes) {
+        const statusColor =
+          proc.status === 'online' ? '\x1b[32m' : proc.status === 'errored' ? '\x1b[31m' : '\x1b[33m';
+        const resetColor = '\x1b[0m';
+        const cpuStr = typeof proc.cpu === 'number' && isFinite(proc.cpu) ? `${proc.cpu.toFixed(1)}%` : '-';
+        const nameDisplay = String(proc.id); // name not carried in IProcessInfo
+        console.log(
+          `│ ${pad(String(proc.id), 7)} │ ${pad(nameDisplay, 11)} │ ${statusColor}${pad(proc.status, 9)}${resetColor} │ ${pad((proc.pid || '-').toString(), 9)} │ ${pad(formatMemory(proc.memory), 8)} │ ${pad(cpuStr, 8)} │ ${pad(proc.restarts.toString(), 8)} │`,
+        );
+      }
+      console.log('└─────────┴─────────────┴───────────┴───────────┴──────────┴──────────┴──────────┘');
+    },
+    { actionLabel: 'get daemon stats' },
+  );
+}
+

ts/cli/index.ts

@@ -20,6 +20,7 @@ import { registerStartAllCommand } from './commands/batch/start-all.js';
 import { registerStopAllCommand } from './commands/batch/stop-all.js';
 import { registerRestartAllCommand } from './commands/batch/restart-all.js';
 import { registerDaemonCommand } from './commands/daemon/index.js';
+import { registerStatsCommand } from './commands/stats.js';
 import { registerEnableCommand } from './commands/service/enable.js';
 import { registerDisableCommand } from './commands/service/disable.js';
 import { registerResetCommand } from './commands/reset.js';
@@ -117,6 +118,7 @@ export const run = async (): Promise<void> => {
 
   // Daemon commands
   registerDaemonCommand(smartcliInstance);
+  registerStatsCommand(smartcliInstance);
 
   // Service commands
   registerEnableCommand(smartcliInstance);

ts/daemon/processmanager.ts

@@ -95,6 +95,16 @@ export class ProcessManager extends EventEmitter {
 
     // Check if process with this id already exists
     if (this.processes.has(config.id)) {
+      const existing = this.processes.get(config.id)!;
+      // If an existing monitor is present but not running, treat this as a fresh start via restart logic
+      if (!existing.isRunning()) {
+        this.logger.info(
+          `Existing monitor found for id '${config.id}' but not running. Restarting it...`,
+        );
+        await this.restart(config.id);
+        return;
+      }
+      // Already running – surface a meaningful error
       throw new ValidationError(
         `Process with id '${config.id}' already exists`,
         'ERR_DUPLICATE_PROCESS',
@@ -246,7 +256,8 @@ export class ProcessManager extends EventEmitter {
 
     try {
       await monitor.stop();
-      this.updateProcessInfo(id, { status: 'stopped' });
+      // Ensure status and PID are reflected immediately
+      this.updateProcessInfo(id, { status: 'stopped', pid: undefined });
       this.logger.info(`Successfully stopped process with id '${id}'`);
     } catch (error: Error | unknown) {
       const processError = new ProcessError(
@@ -430,6 +441,8 @@ export class ProcessManager extends EventEmitter {
         const pid = monitor.getPid();
         if (pid) {
           info.pid = pid;
+        } else {
+          info.pid = undefined;
         }
         
         // Update uptime if available
@@ -438,13 +451,18 @@ export class ProcessManager extends EventEmitter {
           info.uptime = uptime;
         }
         
+        // Update memory and cpu from latest monitor readings
+        info.memory = monitor.getLastMemoryUsage();
+        const cpu = monitor.getLastCpuUsage();
+        if (Number.isFinite(cpu)) {
+          info.cpu = cpu;
+        }
+        
         // Update restart count
         info.restarts = monitor.getRestartCount();
         
         // Update status based on actual running state
-        if (monitor.isRunning()) {
-          info.status = 'online';
-        }
+        info.status = monitor.isRunning() ? 'online' : 'stopped';
       }
     }
     
@@ -492,8 +510,12 @@ export class ProcessManager extends EventEmitter {
    */
   public async startAll(): Promise<void> {
     for (const [id, config] of this.processConfigs.entries()) {
-      if (!this.processes.has(id)) {
+      const monitor = this.processes.get(id);
+      if (!monitor) {
         await this.start(config);
+      } else if (!monitor.isRunning()) {
+        // If a monitor exists but is not running, restart the process to ensure a clean start
+        await this.restart(id);
       }
     }
   }

ts/daemon/processmonitor.ts

@@ -24,6 +24,8 @@ export class ProcessMonitor extends EventEmitter {
   private lastRetryAt: number | null = null;
   private readonly MAX_RETRIES = 10;
   private readonly RESET_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+  private lastMemoryUsage: number = 0;
+  private lastCpuUsage: number = 0;
 
   constructor(config: IMonitorConfig & { id?: ProcessId }) {
     super();
@@ -260,12 +262,16 @@ export class ProcessMonitor extends EventEmitter {
     memoryLimit: number,
   ): Promise<void> {
     try {
-      const memoryUsage = await this.getProcessGroupMemory(pid);
+      const { memory: memoryUsage, cpu: cpuUsage } = await this.getProcessGroupStats(pid);
 
       this.logger.debug(
         `Memory usage for PID ${pid}: ${this.humanReadableBytes(memoryUsage)} (${memoryUsage} bytes)`,
       );
 
+      // Store latest readings
+      this.lastMemoryUsage = memoryUsage;
+      this.lastCpuUsage = cpuUsage;
+
       // Only log memory usage in debug mode to avoid spamming
       if (process.env.TSPM_DEBUG) {
         this.log(
@@ -285,7 +291,7 @@ export class ProcessMonitor extends EventEmitter {
 
         // Stop the process wrapper, which will trigger the exit handler and restart
         if (this.processWrapper) {
-          this.processWrapper.stop();
+          await this.processWrapper.stop();
         }
       }
     } catch (error: Error | unknown) {
@@ -303,7 +309,7 @@ export class ProcessMonitor extends EventEmitter {
   /**
    * Get the total memory usage (in bytes) for the process group (the main process and its children).
    */
-  private getProcessGroupMemory(pid: number): Promise<number> {
+  private getProcessGroupStats(pid: number): Promise<{ memory: number; cpu: number }> {
     return new Promise((resolve, reject) => {
       this.logger.debug(
         `Getting memory usage for process group with PID ${pid}`,
@@ -333,7 +339,7 @@ export class ProcessMonitor extends EventEmitter {
 
           plugins.pidusage(
             pids,
-            (err: Error | null, stats: Record<string, { memory: number }>) => {
+            (err: Error | null, stats: Record<string, { memory: number; cpu: number }>) => {
               if (err) {
                 const processError = new ProcessError(
                   `Failed to get process usage stats: ${err.message}`,
@@ -345,14 +351,16 @@ export class ProcessMonitor extends EventEmitter {
               }
 
               let totalMemory = 0;
+              let totalCpu = 0;
               for (const key in stats) {
                 totalMemory += stats[key].memory;
+                totalCpu += Number.isFinite(stats[key].cpu) ? stats[key].cpu : 0;
               }
 
               this.logger.debug(
                 `Total memory for process group: ${this.humanReadableBytes(totalMemory)}`,
               );
-              resolve(totalMemory);
+              resolve({ memory: totalMemory, cpu: totalCpu });
             },
           );
         },
@@ -392,6 +400,11 @@ export class ProcessMonitor extends EventEmitter {
     if (this.intervalId) {
       clearInterval(this.intervalId);
     }
+    // Cancel any pending restart timer
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
+    }
     if (this.processWrapper) {
       // Clear pidusage state for current PID before stopping to avoid leaks
       try {
@@ -400,7 +413,7 @@ export class ProcessMonitor extends EventEmitter {
           (plugins.pidusage as any)?.clear?.(pidToClear);
         }
       } catch {}
-      this.processWrapper.stop();
+      await this.processWrapper.stop();
     }
   }
 
@@ -448,6 +461,20 @@ export class ProcessMonitor extends EventEmitter {
     return this.processWrapper?.isRunning() || false;
   }
 
+  /**
+   * Get last measured memory usage for the process group (bytes)
+   */
+  public getLastMemoryUsage(): number {
+    return this.lastMemoryUsage;
+  }
+
+  /**
+   * Get last measured CPU usage for the process group (sum of group, percent)
+   */
+  public getLastCpuUsage(): number {
+    return this.lastCpuUsage;
+  }
+
   /**
    * Helper method for logging messages with the instance name.
    */

ts/daemon/processwrapper.ts

@@ -23,6 +23,26 @@ export class ProcessWrapper extends EventEmitter {
   private runId: string = '';
   private stdoutRemainder: string = '';
   private stderrRemainder: string = '';
+  
+  // Helper: send a signal to the process and all its children (best-effort)
+  private async killProcessTree(signal: NodeJS.Signals): Promise<void> {
+    if (!this.process || !this.process.pid) return;
+    const rootPid = this.process.pid;
+    await new Promise<void>((resolve) => {
+      plugins.psTree(rootPid, (err: any, children: ReadonlyArray<{ PID: string }>) => {
+        const pids: number[] = [rootPid, ...children.map((c) => Number(c.PID)).filter((n) => Number.isFinite(n))];
+        for (const pid of pids) {
+          try {
+            // Always signal individual PIDs to avoid accidentally targeting unrelated groups
+            process.kill(pid, signal);
+          } catch {
+            // ignore ESRCH/EPERM
+          }
+        }
+        resolve();
+      });
+    });
+  }
 
   constructor(options: IProcessWrapperOptions) {
     super();
@@ -73,6 +93,9 @@ export class ProcessWrapper extends EventEmitter {
         this.stdoutRemainder = '';
         this.stderrRemainder = '';
         
+        // Mark process reference as gone so isRunning() reflects reality
+        this.process = null;
+        
         this.emit('exit', code, signal);
       });
 
@@ -180,7 +203,7 @@ export class ProcessWrapper extends EventEmitter {
   /**
    * Stop the wrapped process
    */
-  public stop(): void {
+  public async stop(): Promise<void> {
     if (!this.process) {
       this.logger.debug('Stop called but no process is running');
       this.addSystemLog('No process running');
@@ -193,30 +216,46 @@ export class ProcessWrapper extends EventEmitter {
     // First try SIGTERM for graceful shutdown
     if (this.process.pid) {
       try {
-        this.logger.debug(`Sending SIGTERM to process ${this.process.pid}`);
-        process.kill(this.process.pid, 'SIGTERM');
+        this.logger.debug(`Sending SIGTERM to process tree rooted at ${this.process.pid}`);
+        await this.killProcessTree('SIGTERM');
 
-        // Give it 5 seconds to shut down gracefully
-        setTimeout((): void => {
-          if (this.process && this.process.pid) {
+        // If the process already exited, return immediately
+        if (typeof this.process.exitCode === 'number') {
+          this.logger.debug('Process already exited, no need to wait');
+          return;
+        }
+
+        // Wait for exit or escalate
+        await new Promise<void>((resolve) => {
+          let settled = false;
+          const cleanup = () => {
+            if (settled) return;
+            settled = true;
+            resolve();
+          };
+
+          const onExit = () => cleanup();
+          this.process!.once('exit', onExit);
+
+          const killTimer = setTimeout(async () => {
+            if (!this.process || !this.process.pid) return cleanup();
             this.logger.warn(
-              `Process ${this.process.pid} did not exit gracefully, force killing...`,
-            );
-            this.addSystemLog(
-              'Process did not exit gracefully, force killing...',
+              `Process ${this.process.pid} did not exit gracefully, force killing tree...`,
             );
+            this.addSystemLog('Process did not exit gracefully, force killing...');
             try {
-              process.kill(this.process.pid, 'SIGKILL');
-            } catch (error: Error | unknown) {
-              // Process might have exited between checks
-              this.logger.debug(
-                `Failed to send SIGKILL, process probably already exited: ${
-                  error instanceof Error ? error.message : String(error)
-                }`,
-              );
-            }
-          }
-        }, 5000);
+              await this.killProcessTree('SIGKILL');
+            } catch {}
+            // Give a short grace period after SIGKILL
+            setTimeout(() => cleanup(), 500);
+          }, 5000);
+
+          // Safety cap in case neither exit nor timer fires (shouldn't happen)
+          setTimeout(() => {
+            clearTimeout(killTimer);
+            cleanup();
+          }, 10000);
+        });
       } catch (error: Error | unknown) {
         const processError = new ProcessError(
           error instanceof Error ? error.message : String(error),
@@ -233,6 +272,7 @@ export class ProcessWrapper extends EventEmitter {
    * Get the process ID if running
    */
   public getPid(): number | null {
+    if (!this.isRunning()) return null;
     return this.process?.pid || null;
   }
 
@@ -256,7 +296,13 @@ export class ProcessWrapper extends EventEmitter {
    * Check if the process is currently running
    */
   public isRunning(): boolean {
-    return this.process !== null && typeof this.process.exitCode !== 'number';
+    if (!this.process) return false;
+    // In Node, while the child is running: exitCode === null and signalCode === null/undefined
+    // After it exits: exitCode is a number OR signalCode is a string
+    const anyProc: any = this.process as any;
+    const exitCode = anyProc.exitCode;
+    const signalCode = anyProc.signalCode;
+    return exitCode === null && (signalCode === null || typeof signalCode === 'undefined');
   }
 
   /**

ts/daemon/tspm.daemon.ts

@@ -10,6 +10,7 @@ import type {
   DaemonStatusResponse,
   HeartbeatResponse,
 } from '../shared/protocol/ipc.types.js';
+import { LogPersistence } from './logpersistence.js';
 
 /**
  * Central daemon server that manages all TSPM processes
@@ -170,7 +171,22 @@ export class TspmDaemon {
             throw new Error(`Process ${id} not found`);
           }
           await this.tspmInstance.setDesiredState(id, 'online');
-          await this.tspmInstance.start(config);
+          const existing = this.tspmInstance.processes.get(id);
+          if (existing) {
+            if (existing.isRunning()) {
+              // Already running; return current status/pid
+              const runningInfo = this.tspmInstance.processInfo.get(id);
+              return {
+                processId: id,
+                pid: runningInfo?.pid,
+                status: runningInfo?.status || 'online',
+              };
+            } else {
+              await this.tspmInstance.restart(id);
+            }
+          } else {
+            await this.tspmInstance.start(config);
+          }
           const processInfo = this.tspmInstance.processInfo.get(id);
           return {
             processId: id,
@@ -293,7 +309,8 @@ export class TspmDaemon {
     this.ipcServer.onMessage(
       'getLogs',
       async (request: RequestForMethod<'getLogs'>) => {
-        const logs = await this.tspmInstance.getLogs(toProcessId(request.id));
+        const id = toProcessId(request.id);
+        const logs = await this.tspmInstance.getLogs(id, request.lines);
         return { logs };
       },
     );
@@ -346,6 +363,26 @@ export class TspmDaemon {
       },
     );
 
+    // Inspect subscribers for a process log topic
+    this.ipcServer.onMessage(
+      'logs:subscribers',
+      async (
+        request: RequestForMethod<'logs:subscribers'>,
+        clientId: string,
+      ) => {
+        const id = toProcessId(request.id);
+        const topic = `logs.${id}`;
+        try {
+          const topicIndex = (this.ipcServer as any).topicIndex as Map<string, Set<string>> | undefined;
+          const subs = Array.from(topicIndex?.get(topic) || []);
+          // Also include the requesting clientId if it has a local handler without subscription
+          return { topic, subscribers: subs, count: subs.length } as any;
+        } catch (err: any) {
+          return { topic, subscribers: [], count: 0 } as any;
+        }
+      },
+    );
+
     // Resolve target (id:n | name:foo | numeric string) to ProcessId
     this.ipcServer.onMessage(
       'resolveTarget',
@@ -429,10 +466,12 @@ export class TspmDaemon {
 
         await this.tspmInstance.setDesiredStateForAll('stopped');
         await this.tspmInstance.stopAll();
+        // Yield briefly to allow any pending exit events to settle
+        await new Promise((r) => setTimeout(r, 50));
 
-        // Get status of all processes
-        for (const [id, processInfo] of this.tspmInstance.processInfo) {
-          if (processInfo.status === 'stopped') {
+        // Determine which monitors are no longer running
+        for (const [id, monitor] of this.tspmInstance.processes) {
+          if (!monitor.isRunning()) {
             stopped.push(id);
           } else {
             failed.push({ id, error: 'Failed to stop' });
@@ -478,6 +517,28 @@ export class TspmDaemon {
       'daemon:status',
       async (request: RequestForMethod<'daemon:status'>) => {
         const memUsage = process.memoryUsage();
+        // Aggregate log stats from monitors
+        let totalLogCount = 0;
+        let totalLogBytes = 0;
+        const perProcess: Array<{ id: ProcessId; count: number; bytes: number }> = [];
+        for (const [id, monitor] of this.tspmInstance.processes.entries()) {
+          try {
+            const logs = monitor.getLogs();
+            const count = logs.length;
+            const bytes = LogPersistence.calculateLogMemorySize(logs);
+            totalLogCount += count;
+            totalLogBytes += bytes;
+            perProcess.push({ id, count, bytes });
+          } catch {}
+        }
+        const pathsInfo = {
+          tspmDir: paths.tspmDir,
+          socketPath: this.socketPath,
+          pidFile: this.daemonPidFile,
+        };
+        const configsInfo = {
+          processConfigs: this.tspmInstance.processConfigs.size,
+        };
         return {
           status: 'running',
           pid: process.pid,
@@ -486,6 +547,13 @@ export class TspmDaemon {
           memoryUsage: memUsage.heapUsed,
           cpuUsage: process.cpuUsage().user / 1000000, // Convert to seconds
           version: this.version,
+          logsInMemory: {
+            totalCount: totalLogCount,
+            totalBytes: totalLogBytes,
+            perProcess,
+          },
+          paths: pathsInfo,
+          configs: configsInfo,
         };
       },
     );

ts/shared/protocol/ipc.types.ts

@@ -151,6 +151,17 @@ export interface LogsSubscribeResponse {
   ok: boolean;
 }
 
+// Inspect current subscribers for a process log topic
+export interface LogsSubscribersRequest {
+  id: ProcessId;
+}
+
+export interface LogsSubscribersResponse {
+  topic: string;
+  subscribers: string[];
+  count: number;
+}
+
 // Start all command
 export interface StartAllRequest {
   // No parameters needed
@@ -217,6 +228,20 @@ export interface DaemonStatusResponse {
   memoryUsage?: number;
   cpuUsage?: number;
   version?: string;
+  // Additional metadata (optional)
+  paths?: {
+    tspmDir?: string;
+    socketPath?: string;
+    pidFile?: string;
+  };
+  configs?: {
+    processConfigs?: number;
+  };
+  logsInMemory?: {
+    totalCount: number;
+    totalBytes: number;
+    perProcess: Array<{ id: ProcessId; count: number; bytes: number }>;
+  };
 }
 
 // Daemon shutdown command
@@ -287,6 +312,7 @@ export type IpcMethodMap = {
   describe: { request: DescribeRequest; response: DescribeResponse };
   getLogs: { request: GetLogsRequest; response: GetLogsResponse };
   'logs:subscribe': { request: LogsSubscribeRequest; response: LogsSubscribeResponse };
+  'logs:subscribers': { request: LogsSubscribersRequest; response: LogsSubscribersResponse };
   startAll: { request: StartAllRequest; response: StartAllResponse };
   stopAll: { request: StopAllRequest; response: StopAllResponse };
   restartAll: { request: RestartAllRequest; response: RestartAllResponse };