@shepai/cli 1.53.2 → 1.55.0

package/dist/packages/core/src/infrastructure/services/notifications/notification-watcher.service.js

@@ -52,15 +52,17 @@ const EVENT_MESSAGES = {
 export class NotificationWatcherService {
     runRepository;
     phaseTimingRepository;
+    featureRepository;
     notificationService;
     pollIntervalMs;
     trackedRuns = new Map();
     intervalId = null;
     // Suppresses notifications on the first poll to avoid replaying historical state
     isBootstrapped = false;
-    constructor(runRepository, phaseTimingRepository, notificationService, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS) {
+    constructor(runRepository, phaseTimingRepository, featureRepository, notificationService, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS) {
         this.runRepository = runRepository;
         this.phaseTimingRepository = phaseTimingRepository;
+        this.featureRepository = featureRepository;
         this.notificationService = notificationService;
         this.pollIntervalMs = pollIntervalMs;
     }
@@ -87,9 +89,8 @@ export class NotificationWatcherService {
             const runs = await this.runRepository.list();
             await this.processRuns(runs);
         }
-        catch (error) {
-            // eslint-disable-next-line no-console
-            console.warn('NotificationWatcherService poll failed:', error);
+        catch {
+            // DB not ready or query failed — skip this poll cycle
         }
     }
     async processRuns(runs) {
@@ -103,10 +104,11 @@ export class NotificationWatcherService {
             const prevState = this.trackedRuns.get(run.id);
             if (!prevState) {
                 // New run — track and emit initial status event
-                const featureName = this.resolveFeatureName(run);
+                const { featureId, featureName } = await this.resolveFeatureIdentity(run);
                 const newState = {
                     status: run.status,
                     completedPhases: new Set(),
+                    featureId,
                     featureName,
                 };
                 this.trackedRuns.set(run.id, newState);
@@ -151,6 +153,7 @@ export class NotificationWatcherService {
         const event = {
             eventType: mapping.eventType,
             agentRunId: run.id,
+            featureId: state.featureId,
             featureName: state.featureName,
             message: EVENT_MESSAGES[mapping.eventType] ?? `Agent status: ${run.status}`,
             severity: mapping.severity,
@@ -167,6 +170,7 @@ export class NotificationWatcherService {
                     const event = {
                         eventType: NotificationEventType.PhaseCompleted,
                         agentRunId: runId,
+                        featureId: state.featureId,
                         featureName: state.featureName,
                         phaseName: timing.phase,
                         message: `Completed ${timing.phase} phase`,
@@ -178,14 +182,18 @@ export class NotificationWatcherService {
             }
         }
     }
-    resolveFeatureName(run) {
-        // Feature name resolution from featureId would require IFeatureRepository.
-        // For now, use the agentName or a fallback. The NotificationService or
-        // a higher layer can enrich with the actual feature name if needed.
+    async resolveFeatureIdentity(run) {
         if (run.featureId) {
-            return `Feature ${run.featureId}`;
+            try {
+                const feature = await this.featureRepository.findById(run.featureId);
+                if (feature)
+                    return { featureId: feature.id, featureName: feature.name };
+            }
+            catch {
+                // Fall through to fallback
+            }
         }
-        return `Agent ${run.id}`;
+        return { featureId: run.featureId ?? run.id, featureName: `Agent ${run.id}` };
     }
 }
 // --- Singleton accessors (follows getNotificationBus() pattern) ---
@@ -196,11 +204,11 @@ let watcherInstance = null;
  *
  * @throws Error if the watcher is already initialized
  */
-export function initializeNotificationWatcher(runRepository, phaseTimingRepository, notificationService, pollIntervalMs) {
+export function initializeNotificationWatcher(runRepository, phaseTimingRepository, featureRepository, notificationService, pollIntervalMs) {
     if (watcherInstance !== null) {
         throw new Error('Notification watcher already initialized. Cannot re-initialize.');
     }
-    watcherInstance = new NotificationWatcherService(runRepository, phaseTimingRepository, notificationService, pollIntervalMs);
+    watcherInstance = new NotificationWatcherService(runRepository, phaseTimingRepository, featureRepository, notificationService, pollIntervalMs);
 }
 /**
  * Get the notification watcher singleton.

package/dist/src/presentation/cli/commands/_serve.command.d.ts

@@ -0,0 +1,32 @@
+/**
+ * _serve Command (hidden daemon entry point)
+ *
+ * Runs the web server in-process as a detached daemon child.
+ * This command is hidden from --help output and is invoked internally by
+ * the startDaemon() helper via child_process.spawn({detached: true}).
+ *
+ * NOTE: The DI container and settings are already initialized by index.ts
+ * bootstrap() before Commander dispatches to this action. This command
+ * only needs to start the web server and notification watcher.
+ *
+ * Lifecycle:
+ *   1. Start WebServerService on the provided --port
+ *   2. Initialize notification watcher
+ *   3. Block until SIGTERM or SIGINT triggers graceful shutdown
+ *
+ * The shutdown sequence mirrors ui.command.ts:
+ *   - Set isShuttingDown flag (idempotent — prevents double-shutdown)
+ *   - Start 5s forceExit timer (unref'd so it doesn't block)
+ *   - Stop notification watcher
+ *   - Stop WebServerService
+ *   - process.exit(0)
+ *
+ * Usage (internal only):
+ *   process.execPath _serve --port <N>
+ */
+import { Command } from 'commander';
+/**
+ * Create the hidden _serve command (daemon child entry point).
+ */
+export declare function createServeCommand(): Command;
+//# sourceMappingURL=_serve.command.d.ts.map

package/dist/src/presentation/cli/commands/_serve.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_serve.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/_serve.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAuB1D;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAwD5C"}

package/dist/src/presentation/cli/commands/_serve.command.js

@@ -0,0 +1,91 @@
+/**
+ * _serve Command (hidden daemon entry point)
+ *
+ * Runs the web server in-process as a detached daemon child.
+ * This command is hidden from --help output and is invoked internally by
+ * the startDaemon() helper via child_process.spawn({detached: true}).
+ *
+ * NOTE: The DI container and settings are already initialized by index.ts
+ * bootstrap() before Commander dispatches to this action. This command
+ * only needs to start the web server and notification watcher.
+ *
+ * Lifecycle:
+ *   1. Start WebServerService on the provided --port
+ *   2. Initialize notification watcher
+ *   3. Block until SIGTERM or SIGINT triggers graceful shutdown
+ *
+ * The shutdown sequence mirrors ui.command.ts:
+ *   - Set isShuttingDown flag (idempotent — prevents double-shutdown)
+ *   - Start 5s forceExit timer (unref'd so it doesn't block)
+ *   - Stop notification watcher
+ *   - Stop WebServerService
+ *   - process.exit(0)
+ *
+ * Usage (internal only):
+ *   process.execPath _serve --port <N>
+ */
+import { Command, InvalidArgumentError } from 'commander';
+import { container } from '../../../../packages/core/src/infrastructure/di/container.js';
+import { setVersionEnvVars } from '../../../../packages/core/src/infrastructure/services/version.service.js';
+import { resolveWebDir } from '../../../../packages/core/src/infrastructure/services/web-server.service.js';
+import { initializeNotificationWatcher, getNotificationWatcher, } from '../../../../packages/core/src/infrastructure/services/notifications/notification-watcher.service.js';
+function parsePort(value) {
+    const port = parseInt(value, 10);
+    if (isNaN(port) || port < 1024 || port > 65535) {
+        throw new InvalidArgumentError('Port must be an integer between 1024 and 65535');
+    }
+    return port;
+}
+/**
+ * Create the hidden _serve command (daemon child entry point).
+ */
+export function createServeCommand() {
+    const cmd = new Command('_serve')
+        .description('Start the web server daemon (internal use only)')
+        .helpOption(false)
+        .addHelpCommand(false)
+        .option('-p, --port <number>', 'Port to listen on', parsePort)
+        .action(async (options) => {
+        try {
+            const port = options.port ?? 4050;
+            const { dir, dev } = resolveWebDir();
+            // Set version env vars for the web UI
+            const versionService = container.resolve('IVersionService');
+            setVersionEnvVars(versionService.getVersion());
+            // Start the web server
+            const service = container.resolve('IWebServerService');
+            await service.start(port, dir, dev);
+            // Start notification watcher
+            const runRepo = container.resolve('IAgentRunRepository');
+            const phaseTimingRepo = container.resolve('IPhaseTimingRepository');
+            const featureRepo = container.resolve('IFeatureRepository');
+            const notificationService = container.resolve('INotificationService');
+            initializeNotificationWatcher(runRepo, phaseTimingRepo, featureRepo, notificationService);
+            getNotificationWatcher().start();
+            // Graceful shutdown handler — identical pattern to ui.command.ts
+            let isShuttingDown = false;
+            const shutdown = async () => {
+                if (isShuttingDown)
+                    return;
+                isShuttingDown = true;
+                // Force exit after 5s if graceful shutdown stalls
+                const forceExit = setTimeout(() => process.exit(0), 5000);
+                forceExit.unref();
+                getNotificationWatcher().stop();
+                await service.stop();
+                process.exit(0);
+            };
+            process.on('SIGTERM', shutdown);
+            process.on('SIGINT', shutdown);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            // Write to stderr so it appears in daemon logs if redirected
+            process.stderr.write(`[_serve] Fatal error: ${err.message}\n`);
+            process.exit(1);
+        }
+    });
+    // Mark hidden so Commander omits it from --help output
+    cmd._hidden = true;
+    return cmd;
+}

package/dist/src/presentation/cli/commands/daemon/start-daemon.d.ts

@@ -0,0 +1,27 @@
+/**
+ * startDaemon() — Shared daemon-spawn helper
+ *
+ * Contains the parent-side logic for starting the Shep web UI as a
+ * detached background daemon. Used by both:
+ *   - The default `shep` action (index.ts)
+ *   - The `shep start` command (start.command.ts)
+ *
+ * Flow:
+ *   1. Resolve available port (respects --port override)
+ *   2. Check if daemon is already running (idempotent — print URL and return)
+ *   3. Spawn the daemon with execArgv propagated (supports tsx in dev mode)
+ *      {detached: true, stdio: ['ignore','ignore','pipe']} + child.unref()
+ *   4. Wait briefly to confirm the child is alive; surface stderr on crash
+ *   5. Write daemon.json atomically via IDaemonService
+ *   6. Print formatted URL to stdout
+ *   7. Open browser via BrowserOpenerService
+ */
+export interface StartDaemonOptions {
+    port?: number;
+}
+/**
+ * Start the Shep web UI as a detached background daemon.
+ * Idempotent: if a daemon is already running, prints the existing URL and returns.
+ */
+export declare function startDaemon(opts?: StartDaemonOptions): Promise<void>;
+//# sourceMappingURL=start-daemon.d.ts.map

package/dist/src/presentation/cli/commands/daemon/start-daemon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-daemon.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/daemon/start-daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAkBH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,IAAI,GAAE,kBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0F9E"}

package/dist/src/presentation/cli/commands/daemon/start-daemon.js

@@ -0,0 +1,135 @@
+/**
+ * startDaemon() — Shared daemon-spawn helper
+ *
+ * Contains the parent-side logic for starting the Shep web UI as a
+ * detached background daemon. Used by both:
+ *   - The default `shep` action (index.ts)
+ *   - The `shep start` command (start.command.ts)
+ *
+ * Flow:
+ *   1. Resolve available port (respects --port override)
+ *   2. Check if daemon is already running (idempotent — print URL and return)
+ *   3. Spawn the daemon with execArgv propagated (supports tsx in dev mode)
+ *      {detached: true, stdio: ['ignore','ignore','pipe']} + child.unref()
+ *   4. Wait briefly to confirm the child is alive; surface stderr on crash
+ *   5. Write daemon.json atomically via IDaemonService
+ *   6. Print formatted URL to stdout
+ *   7. Open browser via BrowserOpenerService
+ */
+import { spawn } from 'node:child_process';
+import http from 'node:http';
+import { container } from '../../../../../packages/core/src/infrastructure/di/container.js';
+import { findAvailablePort, DEFAULT_PORT } from '../../../../../packages/core/src/infrastructure/services/port.service.js';
+import { BrowserOpenerService } from '../../../../../packages/core/src/infrastructure/services/browser-opener.service.js';
+import { fmt, messages, spinner } from '../../ui/index.js';
+/** How long to wait (ms) after spawn to verify the child is still alive. */
+const SPAWN_SETTLE_MS = 500;
+/** Max time (ms) to wait for the server to become reachable before opening the browser. */
+const READY_TIMEOUT_MS = 30_000;
+/** Interval (ms) between readiness probes. */
+const READY_POLL_MS = 300;
+/**
+ * Start the Shep web UI as a detached background daemon.
+ * Idempotent: if a daemon is already running, prints the existing URL and returns.
+ */
+export async function startDaemon(opts = {}) {
+    const daemonService = container.resolve('IDaemonService');
+    // Check for an already-running daemon
+    const existing = await daemonService.read();
+    if (existing && daemonService.isAlive(existing.pid)) {
+        const url = `http://localhost:${existing.port}`;
+        messages.newline();
+        messages.info(`Shep is already running at ${fmt.code(url)}`);
+        messages.newline();
+        return;
+    }
+    // Resolve the port
+    const startPort = opts.port ?? DEFAULT_PORT;
+    const port = await findAvailablePort(startPort);
+    // Spawn the daemon as a detached child process.
+    // Propagate process.execArgv so tsx loader hooks (--require / --import) are
+    // available in dev mode. In production (compiled JS), execArgv is empty.
+    const child = spawn(process.execPath, [...process.execArgv, process.argv[1], '_serve', '--port', String(port)], {
+        detached: true,
+        // Keep stderr piped so we can surface startup errors; stdin/stdout detached.
+        stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    // Collect stderr in case the child crashes during startup.
+    let stderrChunks = [];
+    child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+    // Wait briefly for the child to either settle or crash.
+    const exitCode = await Promise.race([
+        new Promise((resolve) => child.on('exit', (code) => resolve(code))),
+        new Promise((resolve) => setTimeout(() => resolve(undefined), SPAWN_SETTLE_MS)),
+    ]);
+    if (exitCode !== undefined) {
+        // Child exited during the settle window — startup failed.
+        const stderr = Buffer.concat(stderrChunks).toString().trim();
+        messages.newline();
+        messages.error(`Daemon failed to start (exit code ${exitCode ?? 'unknown'}).`);
+        if (stderr) {
+            console.error(stderr);
+        }
+        messages.newline();
+        // Clean up stale daemon.json if it exists
+        await daemonService.delete();
+        return;
+    }
+    // Child is alive — detach fully.
+    // Unref stderr so the parent event loop is not held open, then unref the child.
+    child.stderr.destroy();
+    stderrChunks = [];
+    child.unref();
+    // Write daemon.json atomically
+    await daemonService.write({
+        pid: child.pid,
+        port,
+        startedAt: new Date().toISOString(),
+    });
+    const url = `http://localhost:${port}`;
+    messages.newline();
+    console.log(fmt.heading('Shep Web UI'));
+    messages.newline();
+    // Poll until the server responds, with a spinner on stderr.
+    // Skip readiness check in E2E / CI environments where the daemon child
+    // cannot actually start a Next.js server within the test's time window.
+    if (process.env.SHEP_SKIP_READINESS_CHECK) {
+        messages.success(`Daemon spawned at ${fmt.code(url)}`);
+    }
+    else {
+        const ready = await spinner('Starting server', () => waitForServer(url, READY_TIMEOUT_MS));
+        if (ready) {
+            messages.success(`Server ready at ${fmt.code(url)}`);
+        }
+        else {
+            messages.warning(`Server may still be starting at ${fmt.code(url)}`);
+        }
+    }
+    messages.newline();
+    const opener = new BrowserOpenerService({ warn: messages.warning });
+    opener.open(url);
+}
+/**
+ * Poll a URL until it returns any HTTP response (even 500).
+ * Resolves true when reachable, false on timeout.
+ */
+function waitForServer(url, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    return new Promise((resolve) => {
+        const probe = () => {
+            if (Date.now() > deadline)
+                return resolve(false);
+            const req = http.get(url, () => {
+                resolve(true);
+            });
+            req.on('error', () => {
+                setTimeout(probe, READY_POLL_MS);
+            });
+            req.setTimeout(2000, () => {
+                req.destroy();
+                setTimeout(probe, READY_POLL_MS);
+            });
+        };
+        probe();
+    });
+}

package/dist/src/presentation/cli/commands/start.command.d.ts

@@ -0,0 +1,15 @@
+/**
+ * start Command
+ *
+ * Starts the Shep web UI as a detached background daemon.
+ * All spawn logic lives in the shared startDaemon() helper to avoid
+ * duplication between this command and the default `shep` action.
+ *
+ * Usage: shep start [--port <number>]
+ */
+import { Command } from 'commander';
+/**
+ * Create the start command.
+ */
+export declare function createStartCommand(): Command;
+//# sourceMappingURL=start.command.d.ts.map

package/dist/src/presentation/cli/commands/start.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/start.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAW1D;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAc5C"}

package/dist/src/presentation/cli/commands/start.command.js

@@ -0,0 +1,33 @@
+/**
+ * start Command
+ *
+ * Starts the Shep web UI as a detached background daemon.
+ * All spawn logic lives in the shared startDaemon() helper to avoid
+ * duplication between this command and the default `shep` action.
+ *
+ * Usage: shep start [--port <number>]
+ */
+import { Command, InvalidArgumentError } from 'commander';
+import { startDaemon } from './daemon/start-daemon.js';
+function parsePort(value) {
+    const port = parseInt(value, 10);
+    if (isNaN(port) || port < 1024 || port > 65535) {
+        throw new InvalidArgumentError('Port must be an integer between 1024 and 65535');
+    }
+    return port;
+}
+/**
+ * Create the start command.
+ */
+export function createStartCommand() {
+    return new Command('start')
+        .description('Start the Shep web UI as a background daemon')
+        .option('-p, --port <number>', 'Port number (1024-65535)', parsePort)
+        .addHelpText('after', `
+Examples:
+  $ shep start               Start on default port (4050)
+  $ shep start --port 8080   Start on custom port`)
+        .action(async (options) => {
+        await startDaemon({ port: options.port });
+    });
+}

package/dist/src/presentation/cli/commands/status.command.d.ts

@@ -0,0 +1,20 @@
+/**
+ * status Command
+ *
+ * Displays live status and metrics for the running Shep web UI daemon.
+ *
+ * Metrics collected:
+ *   - PID, port, URL (from daemon.json)
+ *   - Uptime (computed from startedAt)
+ *   - CPU%, RSS memory (from ps shell-out via execFile — injection-safe)
+ *
+ * Gracefully degrades if ps is unavailable (timeout or error).
+ *
+ * Usage: shep status
+ */
+import { Command } from 'commander';
+/**
+ * Create the status command.
+ */
+export declare function createStatusCommand(): Command;
+//# sourceMappingURL=status.command.d.ts.map

package/dist/src/presentation/cli/commands/status.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/status.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+EpC;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CA2C7C"}

package/dist/src/presentation/cli/commands/status.command.js

@@ -0,0 +1,119 @@
+/**
+ * status Command
+ *
+ * Displays live status and metrics for the running Shep web UI daemon.
+ *
+ * Metrics collected:
+ *   - PID, port, URL (from daemon.json)
+ *   - Uptime (computed from startedAt)
+ *   - CPU%, RSS memory (from ps shell-out via execFile — injection-safe)
+ *
+ * Gracefully degrades if ps is unavailable (timeout or error).
+ *
+ * Usage: shep status
+ */
+import { Command } from 'commander';
+import { execFile } from 'node:child_process';
+import { container } from '../../../../packages/core/src/infrastructure/di/container.js';
+import { renderDetailView, messages } from '../ui/index.js';
+const PS_TIMEOUT_MS = 2000;
+/**
+ * Parse ps output: "pid  cpu%  rss_kb\n"
+ * Returns formatted strings for display.
+ */
+function parsePs(output) {
+    const parts = output.trim().split(/\s+/);
+    const cpu = parts[1] ?? '?';
+    const rssKb = parseFloat(parts[2] ?? '0');
+    const rssMb = (rssKb / 1024).toFixed(1);
+    return { cpu, rssMb };
+}
+/**
+ * Human-readable uptime string, e.g. "2h 14m 3s".
+ */
+function humanizeUptime(ms) {
+    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+/**
+ * Shell out to ps for CPU% and RSS, with a timeout guard.
+ * Uses execFile (not exec) — the PID is a separate array argument,
+ * preventing any possibility of shell injection.
+ */
+function fetchPsMetrics(pid) {
+    return new Promise((resolve) => {
+        const pidStr = String(pid);
+        let settled = false;
+        const fallback = () => ({ cpu: 'unavailable', rssMb: 'unavailable' });
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                child.kill();
+                resolve(fallback());
+            }
+        }, PS_TIMEOUT_MS);
+        const child = execFile('ps', ['-o', 'pid=,pcpu=,rss=', '-p', pidStr], { timeout: PS_TIMEOUT_MS }, (err, stdout) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (err || !stdout.trim()) {
+                resolve(fallback());
+            }
+            else {
+                resolve(parsePs(stdout));
+            }
+        });
+    });
+}
+/**
+ * Create the status command.
+ */
+export function createStatusCommand() {
+    return new Command('status')
+        .description('Show the status of the Shep web UI daemon')
+        .action(async () => {
+        const daemonService = container.resolve('IDaemonService');
+        const state = await daemonService.read();
+        if (!state || !daemonService.isAlive(state.pid)) {
+            messages.newline();
+            messages.info('Shep daemon is not running.');
+            messages.info('Run `shep start` to launch it.');
+            messages.newline();
+            return;
+        }
+        const { pid, port, startedAt } = state;
+        const url = `http://localhost:${port}`;
+        const uptimeMs = Date.now() - Date.parse(startedAt);
+        const uptime = humanizeUptime(uptimeMs);
+        const { cpu, rssMb } = await fetchPsMetrics(pid);
+        renderDetailView({
+            title: 'Shep Daemon Status',
+            sections: [
+                {
+                    fields: [
+                        { label: 'PID', value: String(pid) },
+                        { label: 'Port', value: String(port) },
+                        { label: 'URL', value: url },
+                        { label: 'Started', value: new Date(startedAt).toLocaleString() },
+                        { label: 'Uptime', value: uptime },
+                        { label: 'CPU %', value: cpu === 'unavailable' ? 'unavailable' : `${cpu}%` },
+                        {
+                            label: 'Memory (RSS)',
+                            value: rssMb === 'unavailable' ? 'unavailable' : `${rssMb} MB`,
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+}

package/dist/src/presentation/cli/commands/stop.command.d.ts

@@ -0,0 +1,22 @@
+/**
+ * stop Command
+ *
+ * Stops the running Shep web UI daemon.
+ *
+ * Stop sequence:
+ *   1. Read daemon.json via IDaemonService
+ *   2. If no daemon / PID not alive: print clear message and exit 0
+ *   3. Validate PID is a positive finite integer
+ *   4. Send SIGTERM
+ *   5. Poll process liveness every 200ms for up to 5000ms
+ *   6. If still alive after 5s, send SIGKILL
+ *   7. Always delete daemon.json (in finally block)
+ *
+ * Usage: shep stop
+ */
+import { Command } from 'commander';
+/**
+ * Create the stop command.
+ */
+export declare function createStopCommand(): Command;
+//# sourceMappingURL=stop.command.d.ts.map

package/dist/src/presentation/cli/commands/stop.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/stop.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4BpC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CA+C3C"}