5.3.2

changelog.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 2025-08-30 - 5.3.2 - fix(daemon)
+Improve daemon log delivery and process monitor memory accounting; gate debug output and update tests to numeric ProcessId
+
+- Deliver process logs only to subscribed clients instead of broadcasting to all connections (reduce unnecessary IPC traffic and noise)
+- Implement incremental log memory accounting in ProcessMonitor using an estimateLogSize helper and WeakMap to avoid repeated JSON.stringify and reduce CPU/memory overhead
+- Seed the incremental size map when loading persisted logs so memory accounting is accurate after restart
+- Trim logs incrementally by subtracting estimated sizes of removed entries (avoids O(n) recalculation)
+- Gate verbose console/debug output behind TSPM_DEBUG to prevent spamming in normal runs (applies to ProcessWrapper and ProcessMonitor)
+- Improve process wrapper stdout/stderr debug logging to be conditional on debug mode
+- Update tests to use numeric ProcessId via toProcessId(...) for consistency with typed IDs
+
+## 2025-08-30 - 5.3.1 - fix(client(tspmIpcClient))
+Use bare topic names for IPC client subscribe/unsubscribe to fix log subscription issues
+
+- Updated ts/client/tspm.ipcclient.ts to call ipcClient.subscribe/unsubscribe with the bare topic (e.g. 'logs.<id>') instead of prefixed 'topic:<...>'.
+- Added comments clarifying that the IpcClient registers the 'topic:' prefix internally.
+- Fixes incorrect topic registration that could prevent log streaming handlers from receiving messages.
+
+## 2025-08-30 - 5.3.0 - feat(cli/daemon/processmonitor)
+Add flexible target resolution and search command; improve restart/backoff and error handling
+
+- Add new cli command `search` to find processes by id or name fragment.
+- Allow flexible process targets in CLI commands (accepts numeric id, id:<n>, or name:<label>) for start/stop/restart/delete/describe/logs/edit commands.
+- Introduce a new daemon IPC method `resolveTarget` to normalize user-provided targets to ProcessId (supports id:<n>, name:<label>, or bare numeric id).
+- Keep `remove` as a CLI alias but daemon exposes `delete` only; CLI resolves targets and always calls daemon `delete`.
+- Implement scheduled restart/backoff in ProcessMonitor with incremental debounce, max retries, and a 1-hour reset window.
+- Emit a `failed` event from ProcessMonitor when max restart attempts are exceeded; ProcessManager listens and marks processes as `errored` and clears pid.
+- Ensure desired state is set to `stopped` before deleting a process to avoid race conditions.
+- Improve cli output messages to include resolved names alongside numeric ids where available.
+
 ## 2025-08-30 - 5.2.0 - feat(cli)
 Preserve CLI environment when adding processes, simplify edit flow, and refresh README docs
 

package.json

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

readme.md

@@ -38,21 +38,23 @@ npm install --save-dev @git.zone/tspm
 # Add a process (creates config without starting)
 tspm add "node server.js" --name my-server --memory 1GB
 
-# Start the process
-tspm start my-server
+# Start the process (by name or id)
+tspm start name:my-server
+# or
+tspm start id:1
 
 # Or add and start in one go
 tspm add "node app.js" --name my-app
-tspm start my-app
+tspm start name:my-app
 
 # List all processes
 tspm list
 
 # View logs
-tspm logs my-app
+tspm logs name:my-app
 
 # Stop a process
-tspm stop my-app
+tspm stop name:my-app
 ```
 
 ## 📋 Commands
@@ -86,38 +88,38 @@ tspm add "tsx watch src/index.ts" --name dev-server --watch --watch-paths "src,c
 tspm add "node worker.js" --name one-time-job --autorestart false
 ```
 
-#### `tspm start <id>`
+#### `tspm start <id|id:N|name:LABEL>`
 
 Start a previously added process by its ID or name.
 
 ```bash
-tspm start my-server
-tspm start 1  # Can also use numeric ID
+tspm start name:my-server
+tspm start id:1  # Or a bare numeric id: tspm start 1
 ```
 
-#### `tspm stop <id>`
+#### `tspm stop <id|id:N|name:LABEL>`
 
 Gracefully stop a running process (SIGTERM → SIGKILL after timeout).
 
 ```bash
-tspm stop my-server
+tspm stop name:my-server
 ```
 
-#### `tspm restart <id>`
+#### `tspm restart <id|id:N|name:LABEL>`
 
 Stop and restart a process with the same configuration.
 
 ```bash
-tspm restart my-server
+tspm restart name:my-server
 ```
 
-#### `tspm delete <id>` / `tspm remove <id>`
+#### `tspm delete <id|id:N|name:LABEL>` / `tspm remove <id|id:N|name:LABEL>`
 
 Stop and remove a process from TSPM management. Also deletes persisted logs.
 
 ```bash
-tspm delete old-server
-tspm remove old-server  # Alias for delete
+tspm delete name:old-server
+tspm remove name:old-server  # Alias for delete (daemon handles delete)
 ```
 
 #### `tspm edit <id>`
@@ -148,12 +150,12 @@ tspm list
 └─────────┴─────────────┴───────────┴───────────┴──────────┴──────────┘
 ```
 
-#### `tspm describe <id>`
+#### `tspm describe <id|id:N|name:LABEL>`
 
 Get detailed information about a specific process.
 
 ```bash
-tspm describe my-server
+tspm describe name:my-server
 
 # Output:
 Process Details: my-server
@@ -173,7 +175,7 @@ Auto-restart: true
 Watch:       disabled
 ```
 
-#### `tspm logs <id> [options]`
+#### `tspm logs <id|id:N|name:LABEL> [options]`
 
 View process logs (stdout and stderr combined).
 
@@ -183,13 +185,13 @@ View process logs (stdout and stderr combined).
 
 ```bash
 # View last 50 lines
-tspm logs my-server
+tspm logs name:my-server
 
 # View last 100 lines
-tspm logs my-server --lines 100
+tspm logs name:my-server --lines 100
 
 # Follow logs in real-time
-tspm logs my-server --follow
+tspm logs name:my-server --follow
 ```
 
 ### Batch Operations
@@ -496,7 +498,31 @@ Common issues:
 
 - **"Daemon not running"**: Run `tspm daemon start` or `tspm enable`
 - **"Permission denied"**: Check socket permissions in `~/.tspm/`
-- **"Process won't start"**: Check logs with `tspm logs <id>`
+- **"Process won't start"**: Check logs with `tspm logs <id|id:N|name:LABEL>`
+
+## 🎯 Targeting Processes (IDs and Names)
+
+Most process commands accept the following target formats:
+
+- Numeric ID: `tspm start 1`
+- Explicit ID: `tspm start id:1`
+- Explicit name: `tspm start name:api-server`
+
+Notes:
+- Names must be used with the `name:` prefix.
+- If multiple processes share the same name, the CLI will report the ambiguous matches. Use `id:N` to disambiguate.
+- Use `tspm search <query>` to discover IDs by name or ID fragments.
+
+### `tspm search <query>`
+
+Search processes by name or ID substring and print matching IDs (and names when available):
+
+```bash
+tspm search api
+# Matches for "api":
+# - id:3    name:api-server
+```
+
 - **"Memory limit exceeded"**: Increase limit with `tspm edit <id>`
 
 ## 🤝 Why Choose TSPM?
@@ -515,6 +541,20 @@ Common issues:
 
 ### Perfect For
 
+### Restart Backoff and Failure Handling
+
+TSPM automatically restarts crashed processes with an incremental backoff:
+
+- Debounce delay grows linearly from 1s up to 10s for consecutive retries.
+- After the 10th retry, the process is marked as failed (status: "errored") and auto-restarts stop.
+- The retry counter resets if no retry happens for 1 hour since the last attempt.
+
+You can manually restart a failed process at any time:
+
+```bash
+tspm restart id:1
+```
+
 - 🚀 **Production Node.js apps** - Reliable process management
 - 🔧 **Microservices** - Manage multiple services easily  
 - 👨‍💻 **Development** - File watching and auto-restart

test/test.integration.ts

@@ -5,6 +5,7 @@ import * as fs from 'fs/promises';
 import * as os from 'os';
 import { spawn } from 'child_process';
 import { tspmIpcClient, TspmIpcClient } from '../ts/client/tspm.ipcclient.js';
+import { toProcessId } from '../ts/shared/protocol/id.js';
 
 // Helper to ensure daemon is stopped before tests
 async function ensureDaemonStopped() {
@@ -160,7 +161,7 @@ tap.test('Process management through daemon', async (tools) => {
 
   // Test 2: Start a test process
   const testConfig: tspm.IProcessConfig = {
-    id: 'test-echo',
+    id: toProcessId(1001),
     name: 'Test Echo Process',
     command: 'echo "Test process"',
     projectDir: process.cwd(),
@@ -172,7 +173,7 @@ tap.test('Process management through daemon', async (tools) => {
     config: testConfig,
   });
   console.log('Start response:', startResponse);
-  expect(startResponse.processId).toEqual('test-echo');
+  expect(startResponse.processId).toEqual(1001);
   expect(startResponse.status).toBeDefined();
 
   // Test 3: List processes (should have one process)
@@ -180,27 +181,27 @@ tap.test('Process management through daemon', async (tools) => {
   console.log('List after start:', listResponse);
   expect(listResponse.processes.length).toBeGreaterThanOrEqual(1);
 
-  const procInfo = listResponse.processes.find((p) => p.id === 'test-echo');
+  const procInfo = listResponse.processes.find((p) => p.id === toProcessId(1001));
   expect(procInfo).toBeDefined();
-  expect(procInfo?.id).toEqual('test-echo');
+  expect(procInfo?.id).toEqual(1001);
 
   // Test 4: Describe the process
   const describeResponse = await tspmIpcClient.request('describe', {
-    id: 'test-echo',
+    id: toProcessId(1001),
   });
   console.log('Describe:', describeResponse);
   expect(describeResponse.processInfo).toBeDefined();
   expect(describeResponse.config).toBeDefined();
-  expect(describeResponse.config.id).toEqual('test-echo');
+  expect(describeResponse.config.id).toEqual(1001);
 
   // Test 5: Stop the process
-  const stopResponse = await tspmIpcClient.request('stop', { id: 'test-echo' });
+  const stopResponse = await tspmIpcClient.request('stop', { id: toProcessId(1001) });
   console.log('Stop response:', stopResponse);
   expect(stopResponse.success).toEqual(true);
 
   // Test 6: Delete the process
   const deleteResponse = await tspmIpcClient.request('delete', {
-    id: 'test-echo',
+    id: toProcessId(1001),
   });
   console.log('Delete response:', deleteResponse);
   expect(deleteResponse.success).toEqual(true);
@@ -208,9 +209,7 @@ tap.test('Process management through daemon', async (tools) => {
   // Test 7: Verify process is gone
   listResponse = await tspmIpcClient.request('list', {});
   console.log('List after delete:', listResponse);
-  const deletedProcess = listResponse.processes.find(
-    (p) => p.id === 'test-echo',
-  );
+  const deletedProcess = listResponse.processes.find((p) => p.id === toProcessId(1001));
   expect(deletedProcess).toBeUndefined();
 
   // Cleanup: stop daemon
@@ -241,7 +240,7 @@ tap.test('Batch operations through daemon', async (tools) => {
   // Add multiple test processes
   const testConfigs: tspm.IProcessConfig[] = [
     {
-      id: 'batch-test-1',
+      id: toProcessId(1101),
       name: 'Batch Test 1',
       command: 'echo "Process 1"',
       projectDir: process.cwd(),
@@ -249,7 +248,7 @@ tap.test('Batch operations through daemon', async (tools) => {
       autorestart: false,
     },
     {
-      id: 'batch-test-2',
+      id: toProcessId(1102),
       name: 'Batch Test 2',
       command: 'echo "Process 2"',
       projectDir: process.cwd(),
@@ -308,7 +307,7 @@ tap.test('Daemon error handling', async (tools) => {
 
   // Test 1: Try to stop non-existent process
   try {
-    await tspmIpcClient.request('stop', { id: 'non-existent-process' });
+    await tspmIpcClient.request('stop', { id: toProcessId(99999) });
     expect(false).toEqual(true); // Should not reach here
   } catch (error) {
     expect(error.message).toInclude('Failed to stop process');
@@ -316,7 +315,7 @@ tap.test('Daemon error handling', async (tools) => {
 
   // Test 2: Try to describe non-existent process
   try {
-    await tspmIpcClient.request('describe', { id: 'non-existent-process' });
+    await tspmIpcClient.request('describe', { id: toProcessId(99999) });
     expect(false).toEqual(true); // Should not reach here
   } catch (error) {
     expect(error.message).toInclude('not found');
@@ -324,7 +323,7 @@ tap.test('Daemon error handling', async (tools) => {
 
   // Test 3: Try to restart non-existent process
   try {
-    await tspmIpcClient.request('restart', { id: 'non-existent-process' });
+    await tspmIpcClient.request('restart', { id: toProcessId(99999) });
     expect(false).toEqual(true); // Should not reach here
   } catch (error) {
     expect(error.message).toInclude('Failed to restart process');

test/test.ts

@@ -1,5 +1,6 @@
 import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as tspm from '../ts/index.js';
+import { toProcessId } from '../ts/shared/protocol/id.js';
 import { join } from 'path';
 
 // Basic module import test
@@ -51,7 +52,7 @@ async function exampleUsingIpcClient() {
   // Start a process using the request method
   await client.request('start', {
     config: {
-      id: 'web-server',
+      id: toProcessId(2001),
       name: 'Web Server',
       projectDir: '/path/to/web/project',
       command: 'npm run serve',
@@ -65,7 +66,7 @@ async function exampleUsingIpcClient() {
   // Start another process
   await client.request('start', {
     config: {
-      id: 'api-server',
+      id: toProcessId(2002),
       name: 'API Server',
       projectDir: '/path/to/api/project',
       command: 'npm run api',
@@ -80,13 +81,13 @@ async function exampleUsingIpcClient() {
   
   // Get logs from a process
   const logs = await client.request('getLogs', {
-    id: 'web-server',
+    id: toProcessId(2001),
     lines: 20,
   });
   console.log('Web server logs:', logs.logs);
   
   // Stop a process
-  await client.request('stop', { id: 'api-server' });
+  await client.request('stop', { id: toProcessId(2002) });
   
   // Handle graceful shutdown
   process.on('SIGINT', async () => {

ts/00_commitinfo_data.ts

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

ts/cli/commands/default.ts

@@ -22,13 +22,14 @@ export function registerDefaultCommand(smartcli: plugins.smartcli.Smartcli) {
       );
       console.log('  disable                  Disable TSPM system service');
       console.log('\nProcess Commands:');
-      console.log('  start <script>           Start a process');
+      console.log('  start <id|id:N|name:LBL> Start a process');
       console.log('  list                     List all processes');
-      console.log('  stop <id>                Stop a process');
-      console.log('  restart <id>             Restart a process');
-      console.log('  delete <id>              Delete a process');
-      console.log('  describe <id>            Show details for a process');
-      console.log('  logs <id>                Show logs for a process');
+      console.log('  stop <id|id:N|name:LBL>  Stop a process');
+      console.log('  restart <id|id:N|name:LBL> Restart a process');
+      console.log('  delete <id|id:N|name:LBL> Delete a process');
+      console.log('  describe <id|id:N|name:LBL> Show details for a process');
+      console.log('  logs <id|id:N|name:LBL>  Show logs for a process');
+      console.log('  search <query>           Find processes by id/name');
       console.log('  start-all                Start all saved processes');
       console.log('  stop-all                 Stop all processes');
       console.log('  restart-all              Restart all processes');

ts/cli/commands/process/delete.ts

@@ -8,23 +8,25 @@ export function registerDeleteCommand(smartcli: plugins.smartcli.Smartcli) {
     smartcli,
     ['delete', 'remove'],
     async (argvArg: CliArguments) => {
-      const id = argvArg._[1];
-      if (!id) {
-        console.error('Error: Please provide a process ID');
-        console.log('Usage: tspm delete <id> | tspm remove <id>');
+      const target = argvArg._[1];
+      if (!target) {
+        console.error('Error: Please provide a process target');
+        console.log('Usage: tspm delete <id|id:N|name:LABEL> | tspm remove <id|id:N|name:LABEL>');
         return;
       }
 
       // Determine if command was 'remove' to use the new IPC route, otherwise 'delete'
       const cmd = String(argvArg._[0]);
-      const useRemove = cmd === 'remove';
-      console.log(`${useRemove ? 'Removing' : 'Deleting'} process: ${id}`);
-      const response = await tspmIpcClient.request(useRemove ? 'remove' : 'delete', { id } as any);
+      const isRemoveAlias = cmd === 'remove';
+      console.log(`${isRemoveAlias ? 'Removing' : 'Deleting'} process: ${target}`);
+      const resolved = await tspmIpcClient.request('resolveTarget', { target: String(target) });
+      // Always call daemon 'delete'; 'remove' is CLI alias only
+      const response = await tspmIpcClient.request('delete', { id: resolved.id } as any);
 
       if (response.success) {
-        console.log(`✓ ${response.message || (useRemove ? 'Removed successfully' : 'Deleted successfully')}`);
+        console.log(`✓ ${response.message || (isRemoveAlias ? 'Removed successfully' : 'Deleted successfully')}`);
       } else {
-        console.error(`✗ Failed to ${useRemove ? 'remove' : 'delete'} process: ${response.message}`);
+        console.error(`✗ Failed to ${isRemoveAlias ? 'remove' : 'delete'} process: ${response.message}`);
       }
     },
     { actionLabel: 'delete/remove process' },

ts/cli/commands/process/describe.ts

@@ -9,16 +9,17 @@ export function registerDescribeCommand(smartcli: plugins.smartcli.Smartcli) {
     smartcli,
     'describe',
     async (argvArg: CliArguments) => {
-      const id = argvArg._[1];
-      if (!id) {
-        console.error('Error: Please provide a process ID');
-        console.log('Usage: tspm describe <id>');
+      const target = argvArg._[1];
+      if (!target) {
+        console.error('Error: Please provide a process target');
+        console.log('Usage: tspm describe <id | id:N | name:LABEL>');
         return;
       }
 
-      const response = await tspmIpcClient.request('describe', { id });
+      const resolved = await tspmIpcClient.request('resolveTarget', { target: String(target) });
+      const response = await tspmIpcClient.request('describe', { id: resolved.id });
 
-      console.log(`Process Details: ${id}`);
+      console.log(`Process Details: ${response.config.name || resolved.id}`);
       console.log('─'.repeat(40));
       console.log(`Status:      ${response.processInfo.status}`);
       console.log(`PID:         ${response.processInfo.pid || 'N/A'}`);

ts/cli/commands/process/edit.ts

@@ -9,17 +9,16 @@ export function registerEditCommand(smartcli: plugins.smartcli.Smartcli) {
     smartcli,
     'edit',
     async (argvArg: CliArguments) => {
-      const idRaw = argvArg._[1];
-      if (!idRaw) {
-        console.error('Error: Please provide a process ID to edit');
-        console.log('Usage: tspm edit <id>');
+      const target = argvArg._[1];
+      if (!target) {
+        console.error('Error: Please provide a process target to edit');
+        console.log('Usage: tspm edit <id | id:N | name:LABEL>');
         return;
       }
 
-      const id = idRaw;
-
-      // Load current config
-      const { config } = await tspmIpcClient.request('describe', { id });
+      // Resolve and load current config
+      const resolved = await tspmIpcClient.request('resolveTarget', { target: String(target) });
+      const { config } = await tspmIpcClient.request('describe', { id: resolved.id });
 
       // Interactive editing is temporarily disabled - needs smartinteract API update
       console.log('Interactive editing is temporarily disabled.');
@@ -63,7 +62,7 @@ export function registerEditCommand(smartcli: plugins.smartcli.Smartcli) {
       };
 
       const updateResponse = await tspmIpcClient.request('update', {
-        id,
+        id: resolved.id,
         updates,
       });
 
@@ -73,4 +72,3 @@ export function registerEditCommand(smartcli: plugins.smartcli.Smartcli) {
     { actionLabel: 'edit process config' },
   );
 }
-

ts/cli/commands/process/logs.ts

@@ -11,10 +11,10 @@ export function registerLogsCommand(smartcli: plugins.smartcli.Smartcli) {
     smartcli,
     'logs',
     async (argvArg: CliArguments) => {
-      const id = argvArg._[1];
-      if (!id) {
-        console.error('Error: Please provide a process ID');
-        console.log('Usage: tspm logs <id> [options]');
+      const target = argvArg._[1];
+      if (!target) {
+        console.error('Error: Please provide a process target');
+        console.log('Usage: tspm logs <id | id:N | name:LABEL> [options]');
         console.log('\nOptions:');
         console.log('  --lines <n>   Number of lines to show (default: 50)');
         console.log('  --follow      Stream logs in real-time (like tail -f)');
@@ -24,6 +24,8 @@ export function registerLogsCommand(smartcli: plugins.smartcli.Smartcli) {
       const lines = getNumber(argvArg, 'lines', 50);
       const follow = getBool(argvArg, 'follow', 'f');
 
+      const resolved = await tspmIpcClient.request('resolveTarget', { target: String(target) });
+      const id = resolved.id;
       const response = await tspmIpcClient.request('getLogs', { id, lines });
 
       if (!follow) {
@@ -44,7 +46,7 @@ export function registerLogsCommand(smartcli: plugins.smartcli.Smartcli) {
       }
 
       // Streaming mode
-      console.log(`Logs for process: ${id} (streaming...)`);
+      console.log(`Logs for process: ${resolved.name || id} (streaming...)`);
       console.log('─'.repeat(60));
 
       let lastSeq = 0;

ts/cli/commands/process/restart.ts

@@ -1,6 +1,5 @@
 import * as plugins from '../../plugins.js';
 import { tspmIpcClient } from '../../../client/tspm.ipcclient.js';
-import { toProcessId } from '../../../shared/protocol/id.js';
 import type { CliArguments } from '../../types.js';
 import { registerIpcCommand } from '../../registration/index.js';
 
@@ -11,9 +10,9 @@ export function registerRestartCommand(smartcli: plugins.smartcli.Smartcli) {
     async (argvArg: CliArguments) => {
       const arg = argvArg._[1];
       if (!arg) {
-        console.error('Error: Please provide a process ID or "all"');
+        console.error('Error: Please provide a process target or "all"');
         console.log('Usage:');
-        console.log('  tspm restart <id>');
+        console.log('  tspm restart <id | id:N | name:LABEL>');
         console.log('  tspm restart all');
         return;
       }
@@ -33,12 +32,13 @@ export function registerRestartCommand(smartcli: plugins.smartcli.Smartcli) {
         return;
       }
 
-      const id = String(arg);
-      console.log(`Restarting process: ${id}`);
-      const response = await tspmIpcClient.request('restart', { id: toProcessId(id) });
+      const target = String(arg);
+      console.log(`Restarting process: ${target}`);
+      const resolved = await tspmIpcClient.request('resolveTarget', { target });
+      const response = await tspmIpcClient.request('restart', { id: resolved.id });
 
       console.log(`✓ Process restarted successfully`);
-      console.log(`  ID: ${response.processId}`);
+      console.log(`  ID: ${response.processId}${resolved.name ? ` (name: ${resolved.name})` : ''}`);
       console.log(`  PID: ${response.pid || 'N/A'}`);
       console.log(`  Status: ${response.status}`);
     },

ts/cli/commands/process/search.ts

@@ -0,0 +1,62 @@
+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';
+
+export function registerSearchCommand(smartcli: plugins.smartcli.Smartcli) {
+  registerIpcCommand(
+    smartcli,
+    'search',
+    async (argvArg: CliArguments) => {
+      const query = String(argvArg._[1] || '').trim();
+      if (!query) {
+        console.error('Error: Please provide a search query');
+        console.log('Usage: tspm search <name-fragment | id-fragment>');
+        return;
+      }
+
+      // Fetch list of processes, then enrich with names via describe
+      const listRes = await tspmIpcClient.request('list', {});
+      const processes = listRes.processes;
+
+      // If there are no processes, short-circuit
+      if (processes.length === 0) {
+        console.log('No processes found.');
+        return;
+      }
+
+      const lowerQ = query.toLowerCase();
+      const matches: Array<{ id: number; name?: string }> = [];
+
+      // Collect describe calls to obtain names
+      for (const proc of processes) {
+        try {
+          const desc = await tspmIpcClient.request('describe', { id: proc.id });
+          const name = desc.config.name || '';
+          const idStr = String(proc.id);
+          if (name.toLowerCase().includes(lowerQ) || idStr.includes(query)) {
+            matches.push({ id: proc.id, name });
+          }
+        } catch {
+          // Ignore describe errors for individual processes
+        }
+      }
+
+      if (matches.length === 0) {
+        console.log(`No matches for "${query}"`);
+        return;
+      }
+
+      console.log(`Matches for "${query}":`);
+      for (const m of matches) {
+        if (m.name) {
+          console.log(`- id:${m.id}\tname:${m.name}`);
+        } else {
+          console.log(`- id:${m.id}`);
+        }
+      }
+    },
+    { actionLabel: 'search processes' },
+  );
+}
+

ts/cli/commands/process/start.ts

@@ -10,17 +10,18 @@ export function registerStartCommand(smartcli: plugins.smartcli.Smartcli) {
     smartcli,
     'start',
     async (argvArg: CliArguments) => {
-      const id = argvArg._[1];
-      if (!id) {
-        console.error('Error: Please provide a process ID to start');
-        console.log('Usage: tspm start <id>');
+      const target = argvArg._[1];
+      if (!target) {
+        console.error('Error: Please provide a process target to start');
+        console.log('Usage: tspm start <id | id:N | name:LABEL>');
         return;
       }
 
-      console.log(`Starting process id ${id}...`);
-      const response = await tspmIpcClient.request('startById', { id });
+      console.log(`Starting process: ${target}...`);
+      const resolved = await tspmIpcClient.request('resolveTarget', { target: String(target) });
+      const response = await tspmIpcClient.request('startById', { id: resolved.id });
       console.log('✓ Process started');
-      console.log(`  ID: ${response.processId}`);
+      console.log(`  ID: ${response.processId}${resolved.name ? ` (name: ${resolved.name})` : ''}`);
       console.log(`  PID: ${response.pid || 'N/A'}`);
       console.log(`  Status: ${response.status}`);
     },

ts/cli/commands/process/stop.ts

@@ -8,15 +8,16 @@ export function registerStopCommand(smartcli: plugins.smartcli.Smartcli) {
     smartcli,
     'stop',
     async (argvArg: CliArguments) => {
-      const id = argvArg._[1];
-      if (!id) {
-        console.error('Error: Please provide a process ID');
-        console.log('Usage: tspm stop <id>');
+      const target = argvArg._[1];
+      if (!target) {
+        console.error('Error: Please provide a process target');
+        console.log('Usage: tspm stop <id | id:N | name:LABEL>');
         return;
       }
 
-      console.log(`Stopping process: ${id}`);
-      const response = await tspmIpcClient.request('stop', { id });
+      console.log(`Stopping process: ${target}`);
+      const resolved = await tspmIpcClient.request('resolveTarget', { target: String(target) });
+      const response = await tspmIpcClient.request('stop', { id: resolved.id });
 
       if (response.success) {
         console.log(`✓ ${response.message}`);

ts/cli/index.ts

@@ -10,6 +10,7 @@ import { registerAddCommand } from './commands/process/add.js';
 import { registerStopCommand } from './commands/process/stop.js';
 import { registerRestartCommand } from './commands/process/restart.js';
 import { registerDeleteCommand } from './commands/process/delete.js';
+import { registerSearchCommand } from './commands/process/search.js';
 import { registerListCommand } from './commands/process/list.js';
 import { registerDescribeCommand } from './commands/process/describe.js';
 import { registerLogsCommand } from './commands/process/logs.js';
@@ -74,6 +75,7 @@ export const run = async (): Promise<void> => {
   registerDescribeCommand(smartcliInstance);
   registerLogsCommand(smartcliInstance);
   registerEditCommand(smartcliInstance);
+  registerSearchCommand(smartcliInstance);
 
   // Batch commands
   registerStartAllCommand(smartcliInstance);

ts/client/tspm.ipcclient.ts

@@ -155,7 +155,9 @@ export class TspmIpcClient {
 
     const id = toProcessId(processId);
     const topic = `logs.${id}`;
-    await this.ipcClient.subscribe(`topic:${topic}`, handler);
+    // Note: IpcClient.subscribe expects the bare topic (without the 'topic:' prefix)
+    // and will register a handler for 'topic:<topic>' internally.
+    await this.ipcClient.subscribe(topic, handler);
   }
 
   /**
@@ -168,7 +170,8 @@ export class TspmIpcClient {
 
     const id = toProcessId(processId);
     const topic = `logs.${id}`;
-    await this.ipcClient.unsubscribe(`topic:${topic}`);
+    // Pass bare topic; client handles 'topic:' prefix internally
+    await this.ipcClient.unsubscribe(topic);
   }
 
   /**

ts/daemon/processmanager.ts

@@ -156,6 +156,11 @@ export class ProcessManager extends EventEmitter {
         this.updateProcessInfo(config.id, { pid: undefined });
       });
 
+      // Set up failure handler to mark process as errored
+      monitor.on('failed', () => {
+        this.updateProcessInfo(config.id, { status: 'errored', pid: undefined });
+      });
+
       await monitor.start();
 
       // Wait a moment for the process to spawn and get its PID
@@ -327,6 +332,11 @@ export class ProcessManager extends EventEmitter {
         });
       }
 
+      // Mark errored on failure events
+      newMonitor.on('failed', () => {
+        this.updateProcessInfo(id, { status: 'errored', pid: undefined });
+      });
+
       this.logger.info(`Successfully restarted process with id '${id}'`);
     } catch (error: Error | unknown) {
       const processError = new ProcessError(

ts/daemon/processmonitor.ts

@@ -18,6 +18,12 @@ export class ProcessMonitor extends EventEmitter {
   private processId?: ProcessId;
   private currentLogMemorySize: number = 0;
   private readonly MAX_LOG_MEMORY_SIZE = 10 * 1024 * 1024; // 10MB
+  // Track approximate size per log to avoid O(n) JSON stringify on every update
+  private logSizeMap: WeakMap<IProcessLog, number> = new WeakMap();
+  private restartTimer: NodeJS.Timeout | null = null;
+  private lastRetryAt: number | null = null;
+  private readonly MAX_RETRIES = 10;
+  private readonly RESET_WINDOW_MS = 60 * 60 * 1000; // 1 hour
 
   constructor(config: IMonitorConfig & { id?: ProcessId }) {
     super();
@@ -35,7 +41,13 @@ export class ProcessMonitor extends EventEmitter {
       const persistedLogs = await this.logPersistence.loadLogs(this.processId);
       if (persistedLogs.length > 0) {
         this.logs = persistedLogs;
-        this.currentLogMemorySize = LogPersistence.calculateLogMemorySize(this.logs);
+        // Recalculate size once from scratch and seed the size map
+        this.currentLogMemorySize = 0;
+        for (const log of this.logs) {
+          const size = this.estimateLogSize(log);
+          this.logSizeMap.set(log, size);
+          this.currentLogMemorySize += size;
+        }
         this.logger.info(`Loaded ${persistedLogs.length} persisted logs from disk`);
         
         // Delete the persisted file after loading
@@ -83,18 +95,27 @@ export class ProcessMonitor extends EventEmitter {
     this.processWrapper.on('log', (log: IProcessLog): void => {
       // Store the log in our buffer
       this.logs.push(log);
-      console.error(`[ProcessMonitor:${this.config.name}] Received log (type=${log.type}): ${log.message}`);
-      console.error(`[ProcessMonitor:${this.config.name}] Logs array now has ${this.logs.length} items`);
+      if (process.env.TSPM_DEBUG) {
+        console.error(
+          `[ProcessMonitor:${this.config.name}] Received log (type=${log.type}): ${log.message}`,
+        );
+        console.error(
+          `[ProcessMonitor:${this.config.name}] Logs array now has ${this.logs.length} items`,
+        );
+      }
       this.logger.debug(`ProcessMonitor received log: ${log.message}`);
       
-      // Update memory size tracking
-      this.currentLogMemorySize = LogPersistence.calculateLogMemorySize(this.logs);
+      // Update memory size tracking incrementally
+      const approxSize = this.estimateLogSize(log);
+      this.logSizeMap.set(log, approxSize);
+      this.currentLogMemorySize += approxSize;
       
       // Trim logs if they exceed memory limit (10MB)
       while (this.currentLogMemorySize > this.MAX_LOG_MEMORY_SIZE && this.logs.length > 1) {
         // Remove oldest logs until we're under the memory limit
-        this.logs.shift();
-        this.currentLogMemorySize = LogPersistence.calculateLogMemorySize(this.logs);
+        const removed = this.logs.shift()!;
+        const removedSize = this.logSizeMap.get(removed) ?? this.estimateLogSize(removed);
+        this.currentLogMemorySize -= removedSize;
       }
       
       // Re-emit the log event for upstream handlers
@@ -132,10 +153,7 @@ export class ProcessMonitor extends EventEmitter {
         this.emit('exit', code, signal);
 
         if (!this.stopped) {
-          this.logger.info('Restarting process...');
-          this.log('Restarting process...');
-          this.restartCount++;
-          this.spawnProcess();
+          this.scheduleRestart('exit');
         } else {
           this.logger.debug(
             'Not restarting process because monitor is stopped',
@@ -164,10 +182,7 @@ export class ProcessMonitor extends EventEmitter {
       }
 
       if (!this.stopped) {
-        this.logger.info('Restarting process due to error...');
-        this.log('Restarting process due to error...');
-        this.restartCount++;
-        this.spawnProcess();
+        this.scheduleRestart('error');
       } else {
         this.logger.debug('Not restarting process because monitor is stopped');
       }
@@ -185,6 +200,49 @@ export class ProcessMonitor extends EventEmitter {
     }
   }
 
+  /**
+   * Schedule a restart with incremental debounce and failure cutoff.
+   */
+  private scheduleRestart(reason: 'exit' | 'error'): void {
+    const now = Date.now();
+    // Reset window: if last retry was more than 1 hour ago, reset counter
+    if (this.lastRetryAt && now - this.lastRetryAt >= this.RESET_WINDOW_MS) {
+      this.logger.info('Resetting retry counter after 1 hour window');
+      this.restartCount = 0;
+    }
+
+    // Already at or above max retries?
+    if (this.restartCount >= this.MAX_RETRIES) {
+      const msg = 'Maximum restart attempts reached. Marking process as failed.';
+      this.logger.warn(msg);
+      this.log(msg);
+      this.stopped = true;
+      // Emit a specific event so manager can set status to errored
+      this.emit('failed');
+      return;
+    }
+
+    // Increment and compute delay (1..10 seconds)
+    this.restartCount++;
+    const delaySec = Math.min(this.restartCount, 10);
+    const msg = `Restarting process in ${delaySec}s (attempt ${this.restartCount}/${this.MAX_RETRIES}) due to ${reason}...`;
+    this.logger.info(msg);
+    this.log(msg);
+
+    // Clear existing timer if any, then schedule
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+    }
+    this.lastRetryAt = now;
+    this.restartTimer = setTimeout(() => {
+      // If stopped in the meantime, do not spawn
+      if (this.stopped) {
+        return;
+      }
+      this.spawnProcess();
+    }, delaySec * 1000);
+  }
+
   /**
    * Monitor the process group's memory usage. If the total memory exceeds the limit,
    * kill the process group so that the 'exit' handler can restart it.
@@ -200,12 +258,14 @@ export class ProcessMonitor extends EventEmitter {
         `Memory usage for PID ${pid}: ${this.humanReadableBytes(memoryUsage)} (${memoryUsage} bytes)`,
       );
 
-      // Only log to the process log at longer intervals to avoid spamming
-      this.log(
-        `Current memory usage for process group (PID ${pid}): ${this.humanReadableBytes(
-          memoryUsage,
-        )} (${memoryUsage} bytes)`,
-      );
+      // Only log memory usage in debug mode to avoid spamming
+      if (process.env.TSPM_DEBUG) {
+        this.log(
+          `Current memory usage for process group (PID ${pid}): ${this.humanReadableBytes(
+            memoryUsage,
+          )} (${memoryUsage} bytes)`,
+        );
+      }
 
       if (memoryUsage > memoryLimit) {
         const memoryLimitMsg = `Memory usage ${this.humanReadableBytes(
@@ -333,7 +393,11 @@ export class ProcessMonitor extends EventEmitter {
    * Get the current logs from the process
    */
   public getLogs(limit?: number): IProcessLog[] {
-    console.error(`[ProcessMonitor:${this.config.name}] getLogs called, logs.length=${this.logs.length}, limit=${limit}`);
+    if (process.env.TSPM_DEBUG) {
+      console.error(
+        `[ProcessMonitor:${this.config.name}] getLogs called, logs.length=${this.logs.length}, limit=${limit}`,
+      );
+    }
     this.logger.debug(`Getting logs, total stored: ${this.logs.length}`);
     if (limit && limit > 0) {
       return this.logs.slice(-limit);
@@ -376,4 +440,17 @@ export class ProcessMonitor extends EventEmitter {
     const prefix = this.config.name ? `[${this.config.name}] ` : '';
     console.log(prefix + message);
   }
+
+  /**
+   * Estimate approximate memory size in bytes for a log entry.
+   * Keeps CPU low by avoiding JSON.stringify on the full array.
+   */
+  private estimateLogSize(log: IProcessLog): number {
+    const messageBytes = Buffer.byteLength(log.message || '', 'utf8');
+    const typeBytes = Buffer.byteLength(log.type || '', 'utf8');
+    const runIdBytes = Buffer.byteLength((log as any).runId || '', 'utf8');
+    // Rough overhead for object structure, keys, timestamp/seq values
+    const overhead = 64;
+    return messageBytes + typeBytes + runIdBytes + overhead;
+  }
 }

ts/daemon/processwrapper.ts

@@ -90,9 +90,19 @@ export class ProcessWrapper extends EventEmitter {
 
       // Capture stdout
       if (this.process.stdout) {
-        console.error(`[ProcessWrapper] Setting up stdout listener for process ${this.process.pid}`);
+        if (process.env.TSPM_DEBUG) {
+          console.error(
+            `[ProcessWrapper] Setting up stdout listener for process ${this.process.pid}`,
+          );
+        }
         this.process.stdout.on('data', (data) => {
-          console.error(`[ProcessWrapper] Received stdout data from PID ${this.process?.pid}: ${data.toString().substring(0, 100)}`);
+          if (process.env.TSPM_DEBUG) {
+            console.error(
+              `[ProcessWrapper] Received stdout data from PID ${this.process?.pid}: ${data
+                .toString()
+                .substring(0, 100)}`,
+            );
+          }
           // Add data to remainder buffer and split by newlines
           const text = this.stdoutRemainder + data.toString();
           const lines = text.split('\n');
@@ -102,7 +112,9 @@ export class ProcessWrapper extends EventEmitter {
           
           // Process complete lines
           for (const line of lines) {
-            console.error(`[ProcessWrapper] Processing stdout line: ${line}`);
+            if (process.env.TSPM_DEBUG) {
+              console.error(`[ProcessWrapper] Processing stdout line: ${line}`);
+            }
             this.logger.debug(`Captured stdout: ${line}`);
             this.addLog('stdout', line);
           }

ts/daemon/tspm.daemon.ts

@@ -97,9 +97,25 @@ export class TspmDaemon {
     this.tspmInstance.on('process:log', ({ processId, log }) => {
       // Publish to topic for this process
       const topic = `logs.${processId}`;
-      // Broadcast to all connected clients subscribed to this topic
+      // Deliver only to subscribed clients
       if (this.ipcServer) {
-        this.ipcServer.broadcast(`topic:${topic}`, log);
+        try {
+          const topicIndex = (this.ipcServer as any).topicIndex as Map<string, Set<string>> | undefined;
+          const subscribers = topicIndex?.get(topic);
+          if (subscribers && subscribers.size > 0) {
+            // Send directly to subscribers for this topic
+            for (const clientId of subscribers) {
+              this.ipcServer
+                .sendToClient(clientId, `topic:${topic}`, log)
+                .catch((err: any) => {
+                  // Surface but don't fail the loop
+                  console.error('[IPC] sendToClient error:', err?.message || err);
+                });
+            }
+          }
+        } catch (err: any) {
+          console.error('[IPC] Topic delivery error:', err?.message || err);
+        }
       }
     });
 
@@ -208,6 +224,8 @@ export class TspmDaemon {
       async (request: RequestForMethod<'delete'>) => {
         try {
           const id = toProcessId(request.id);
+          // Ensure desired state reflects stopped before deletion
+          await this.tspmInstance.setDesiredState(id, 'stopped');
           await this.tspmInstance.delete(id);
           return {
             success: true,
@@ -246,18 +264,7 @@ export class TspmDaemon {
       },
     );
 
-    this.ipcServer.onMessage(
-      'remove',
-      async (request: RequestForMethod<'remove'>) => {
-        try {
-          const id = toProcessId(request.id);
-          await this.tspmInstance.delete(id);
-          return { success: true, message: `Process ${id} deleted successfully` };
-        } catch (error) {
-          throw new Error(`Failed to remove process: ${error.message}`);
-        }
-      },
-    );
+    // Note: 'remove' is only a CLI alias. Daemon exposes 'delete' only.
 
     this.ipcServer.onMessage(
       'list',
@@ -291,6 +298,58 @@ export class TspmDaemon {
       },
     );
 
+    // Resolve target (id:n | name:foo | numeric string) to ProcessId
+    this.ipcServer.onMessage(
+      'resolveTarget',
+      async (request: RequestForMethod<'resolveTarget'>) => {
+        const raw = String(request.target || '').trim();
+        if (!raw) {
+          throw new Error('Empty target');
+        }
+
+        // id:<n>
+        if (/^id:\s*\d+$/i.test(raw)) {
+          const idNum = raw.split(':')[1].trim();
+          const id = toProcessId(idNum);
+          const config = this.tspmInstance.processConfigs.get(id);
+          if (!config) throw new Error(`Process ${id} not found`);
+          return { id, name: config.name } as ResponseForMethod<'resolveTarget'>;
+        }
+
+        // name:<label>
+        if (/^name:/i.test(raw)) {
+          const name = raw.slice(raw.indexOf(':') + 1).trim();
+          if (!name) throw new Error('Missing name after name:');
+          const matches = Array.from(this.tspmInstance.processConfigs.values()).filter(
+            (c) => (c.name || '').trim() === name,
+          );
+          if (matches.length === 0) {
+            throw new Error(`No process found with name "${name}"`);
+          }
+          if (matches.length > 1) {
+            const ids = matches.map((c) => String(c.id)).join(', ');
+            throw new Error(
+              `Multiple processes found with name "${name}": ids [${ids}]. Please use id:<n>.`,
+            );
+          }
+          return { id: matches[0].id, name } as ResponseForMethod<'resolveTarget'>;
+        }
+
+        // bare numeric id
+        if (/^\d+$/.test(raw)) {
+          const id = toProcessId(raw);
+          const config = this.tspmInstance.processConfigs.get(id);
+          if (!config) throw new Error(`Process ${id} not found`);
+          return { id, name: config.name } as ResponseForMethod<'resolveTarget'>;
+        }
+
+        // Unknown format
+        throw new Error(
+          'Unsupported target format. Use numeric id (e.g. 1), id:<n> (e.g. id:1), or name:<label> (e.g. name:api).',
+        );
+      },
+    );
+
     // Batch operations handlers
     this.ipcServer.onMessage(
       'startAll',

ts/shared/protocol/ipc.types.ts

@@ -240,14 +240,6 @@ export interface AddResponse {
 }
 
 // Remove (delete config and stop if running)
-export interface RemoveRequest {
-  id: ProcessId;
-}
-
-export interface RemoveResponse {
-  success: boolean;
-  message?: string;
-}
 
 // Update (modify existing config)
 export interface UpdateRequest {
@@ -260,6 +252,16 @@ export interface UpdateResponse {
   config: IProcessConfig;
 }
 
+// Resolve a user-provided target (id:n or name:foo or numeric string) to a ProcessId
+export interface ResolveTargetRequest {
+  target: string;
+}
+
+export interface ResolveTargetResponse {
+  id: ProcessId;
+  name?: string;
+}
+
 // Type mappings for methods
 export type IpcMethodMap = {
   start: { request: StartRequest; response: StartResponse };
@@ -269,7 +271,6 @@ export type IpcMethodMap = {
   delete: { request: DeleteRequest; response: DeleteResponse };
   add: { request: AddRequest; response: AddResponse };
   update: { request: UpdateRequest; response: UpdateResponse };
-  remove: { request: RemoveRequest; response: RemoveResponse };
   list: { request: ListRequest; response: ListResponse };
   describe: { request: DescribeRequest; response: DescribeResponse };
   getLogs: { request: GetLogsRequest; response: GetLogsResponse };
@@ -286,6 +287,7 @@ export type IpcMethodMap = {
     response: DaemonShutdownResponse;
   };
   heartbeat: { request: HeartbeatRequest; response: HeartbeatResponse };
+  resolveTarget: { request: ResolveTargetRequest; response: ResolveTargetResponse };
 };
 
 // Helper type to extract request type for a method