@shepai/cli 1.53.2 → 1.55.0

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

@@ -0,0 +1,79 @@
+/**
+ * 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';
+import { container } from '../../../../packages/core/src/infrastructure/di/container.js';
+import { messages } from '../ui/index.js';
+const POLL_INTERVAL_MS = 200;
+const MAX_WAIT_MS = 5000;
+/**
+ * Poll until the given PID is dead or the timeout expires.
+ * Returns true if the process is dead, false if it survived the timeout.
+ */
+async function pollUntilDead(daemonService, pid, maxMs, intervalMs) {
+    const deadline = Date.now() + maxMs;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        if (!daemonService.isAlive(pid)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Create the stop command.
+ */
+export function createStopCommand() {
+    return new Command('stop').description('Stop the running Shep web UI daemon').action(async () => {
+        const daemonService = container.resolve('IDaemonService');
+        const state = await daemonService.read();
+        // No daemon running or PID not alive
+        if (!state || !daemonService.isAlive(state.pid)) {
+            messages.info('No Shep daemon is running.');
+            await daemonService.delete();
+            return;
+        }
+        const { pid } = state;
+        // Validate PID is a positive finite integer before kill
+        if (!Number.isFinite(pid) || !Number.isInteger(pid) || pid <= 0) {
+            messages.info('No Shep daemon is running (invalid PID in state file).');
+            await daemonService.delete();
+            return;
+        }
+        try {
+            messages.info(`Stopping Shep daemon (PID ${pid})...`);
+            // Send SIGTERM — request graceful shutdown
+            process.kill(pid, 'SIGTERM');
+            // Poll for up to 5s waiting for the process to exit
+            const died = await pollUntilDead(daemonService, pid, MAX_WAIT_MS, POLL_INTERVAL_MS);
+            if (!died) {
+                // Graceful shutdown timed out — force kill
+                messages.info('Daemon did not stop gracefully, sending SIGKILL...');
+                try {
+                    process.kill(pid, 'SIGKILL');
+                }
+                catch {
+                    // Process may have exited between the check and the kill — ignore
+                }
+            }
+            messages.success('Shep daemon stopped.');
+        }
+        finally {
+            // Always clean up daemon.json regardless of termination path
+            await daemonService.delete();
+        }
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"ui.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/ui.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAyB1D;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CA2EzC"}
+{"version":3,"file":"ui.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/ui.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AA0B1D;;GAEG;AACH,wBAAgB,eAAe,IAAI,OAAO,CA4EzC"}

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

@@ -59,8 +59,9 @@ Examples:
             // Start notification watcher to detect agent status transitions
             const runRepo = container.resolve('IAgentRunRepository');
             const phaseTimingRepo = container.resolve('IPhaseTimingRepository');
+            const featureRepo = container.resolve('IFeatureRepository');
             const notificationService = container.resolve('INotificationService');
-            initializeNotificationWatcher(runRepo, phaseTimingRepo, notificationService);
+            initializeNotificationWatcher(runRepo, phaseTimingRepo, featureRepo, notificationService);
             getNotificationWatcher().start();
             const url = `http://localhost:${port}`;
             messages.success(`Server ready at ${fmt.code(url)}`);

package/dist/src/presentation/cli/index.d.ts

@@ -8,9 +8,12 @@
  *   shep [command] [options]
  *
  * Commands:
- *   shep              Show help
+ *   shep              Start the web UI daemon (or run onboarding on first run)
+ *   shep start        Start the web UI as a background daemon
+ *   shep stop         Stop the running web UI daemon
+ *   shep status       Show status and metrics of the running daemon
  *   shep version      Display version information
- *   shep ui           Start the web UI
+ *   shep ui           Start the web UI (foreground, interactive)
  *   shep run          Run an AI agent workflow
  *   shep agent        Manage and view agent runs
  *   shep feat         Manage features through the SDLC lifecycle

package/dist/src/presentation/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/presentation/cli/index.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/presentation/cli/index.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,kBAAkB,CAAC"}

package/dist/src/presentation/cli/index.js

@@ -8,9 +8,12 @@
  *   shep [command] [options]
  *
  * Commands:
- *   shep              Show help
+ *   shep              Start the web UI daemon (or run onboarding on first run)
+ *   shep start        Start the web UI as a background daemon
+ *   shep stop         Stop the running web UI daemon
+ *   shep status       Show status and metrics of the running daemon
  *   shep version      Display version information
- *   shep ui           Start the web UI
+ *   shep ui           Start the web UI (foreground, interactive)
  *   shep run          Run an AI agent workflow
  *   shep agent        Manage and view agent runs
  *   shep feat         Manage features through the SDLC lifecycle
@@ -38,6 +41,12 @@ import { createIdeOpenCommand } from './commands/ide-open.command.js';
 import { createInstallCommand } from './commands/install.command.js';
 import { createUpgradeCommand } from './commands/upgrade.command.js';
 import { messages } from './ui/index.js';
+// Daemon lifecycle commands
+import { createStartCommand } from './commands/start.command.js';
+import { createStopCommand } from './commands/stop.command.js';
+import { createStatusCommand } from './commands/status.command.js';
+import { createServeCommand } from './commands/_serve.command.js';
+import { startDaemon } from './commands/daemon/start-daemon.js';
 // DI container and settings
 import { initializeContainer, container } from '../../../packages/core/src/infrastructure/di/container.js';
 import { InitializeSettingsUseCase } from '../../../packages/core/src/application/use-cases/settings/initialize-settings.use-case.js';
@@ -88,8 +97,13 @@ async function bootstrap() {
             .name('shep')
             .description(description)
             .version(version, '-v, --version', 'Display version number')
-            .action(() => {
-            program.outputHelp();
+            // task-10: Default action starts the daemon (or shows already-running URL).
+            // The onboarding gate above (lines 82-89) ensures the wizard runs on first launch;
+            // after the gate, startDaemon() is the correct next step in both cases.
+            // Commander only fires this action when no subcommand matches, so `shep start` etc.
+            // are unaffected.
+            .action(async () => {
+            await startDaemon();
         });
         // Register commands
         program.addCommand(createVersionCommand());
@@ -103,6 +117,11 @@ async function bootstrap() {
         program.addCommand(createIdeOpenCommand());
         program.addCommand(createInstallCommand());
         program.addCommand(createUpgradeCommand());
+        // Daemon lifecycle commands (task-9)
+        program.addCommand(createStartCommand());
+        program.addCommand(createStopCommand());
+        program.addCommand(createStatusCommand());
+        program.addCommand(createServeCommand()); // hidden from --help
         // Parse arguments (parseAsync needed for async command actions like init)
         await program.parseAsync();
     }

package/dist/src/presentation/web/app/api/agent-events/health/route.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SSE Health Check: GET /api/agent-events/health
+ *
+ * Diagnostic endpoint that verifies the SSE pipeline prerequisites:
+ * - DI container is accessible from API routes
+ * - Feature listing works
+ * - Agent run repository works
+ *
+ * Use this in the browser to verify the SSE system is functional.
+ */
+export declare const dynamic = "force-dynamic";
+export declare function GET(): Promise<Response>;
+//# sourceMappingURL=route.d.ts.map

package/dist/src/presentation/web/app/api/agent-events/health/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../../src/presentation/web/app/api/agent-events/health/route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAEvC,wBAAsB,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,CAmD7C"}

package/dist/src/presentation/web/app/api/agent-events/health/route.js

@@ -0,0 +1,60 @@
+/**
+ * SSE Health Check: GET /api/agent-events/health
+ *
+ * Diagnostic endpoint that verifies the SSE pipeline prerequisites:
+ * - DI container is accessible from API routes
+ * - Feature listing works
+ * - Agent run repository works
+ *
+ * Use this in the browser to verify the SSE system is functional.
+ */
+import { resolve } from '../../../../lib/server-container.js';
+export const dynamic = 'force-dynamic';
+export async function GET() {
+    const checks = {};
+    // Check 1: DI container accessible
+    try {
+        resolve('ListFeaturesUseCase');
+        checks.container = { ok: true };
+    }
+    catch (error) {
+        checks.container = {
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+    // Check 2: Feature listing works
+    try {
+        const listFeatures = resolve('ListFeaturesUseCase');
+        const features = await listFeatures.execute();
+        const withRuns = features.filter((f) => f.agentRunId).length;
+        checks.features = {
+            ok: true,
+            detail: `${features.length} features (${withRuns} with agent runs)`,
+        };
+    }
+    catch (error) {
+        checks.features = {
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+    // Check 3: Agent run repository works
+    try {
+        const agentRunRepo = resolve('IAgentRunRepository');
+        const runs = await agentRunRepo.list();
+        const active = runs.filter((r) => r.status === 'running' || r.status === 'pending' || r.status === 'waiting_approval').length;
+        checks.agentRuns = {
+            ok: true,
+            detail: `${runs.length} runs (${active} active)`,
+        };
+    }
+    catch (error) {
+        checks.agentRuns = {
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const allOk = Object.values(checks).every((c) => c.ok);
+    return Response.json({ ok: allOk, checks }, { status: allOk ? 200 : 503 });
+}

package/dist/src/presentation/web/app/api/agent-events/route.d.ts

@@ -2,13 +2,17 @@
  * SSE API Route: GET /api/agent-events
  *
  * Streams agent lifecycle notification events to connected web UI clients
- * via Server-Sent Events (SSE). This is the first API route in the web UI.
+ * via Server-Sent Events (SSE).
  *
- * - Subscribes to the notification event bus (lazy-initialized singleton)
- * - Formats events as SSE data frames (event: notification\ndata: JSON\n\n)
+ * Uses DB polling with a per-connection cache so only deltas are sent.
+ * This avoids cross-module singleton issues with an in-process event bus.
+ *
+ * - Polls features + agent runs every 500ms
+ * - Compares against cached state and emits only changes
  * - Sends heartbeat comments every 30 seconds to keep connection alive
  * - Supports optional ?runId query parameter to filter events
- * - Cleans up listeners and intervals on client disconnect
+ * - Cleans up intervals on client disconnect
  */
+export declare const dynamic = "force-dynamic";
 export declare function GET(request: Request): Response;
 //# sourceMappingURL=route.d.ts.map

package/dist/src/presentation/web/app/api/agent-events/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/app/api/agent-events/route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAeH,wBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAsD9C"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/app/api/agent-events/route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAgBH,eAAO,MAAM,OAAO,kBAAkB,CAAC;AA4DvC,wBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAkM9C"}

package/dist/src/presentation/web/app/api/agent-events/route.js

@@ -2,69 +2,241 @@
  * SSE API Route: GET /api/agent-events
  *
  * Streams agent lifecycle notification events to connected web UI clients
- * via Server-Sent Events (SSE). This is the first API route in the web UI.
+ * via Server-Sent Events (SSE).
  *
- * - Subscribes to the notification event bus (lazy-initialized singleton)
- * - Formats events as SSE data frames (event: notification\ndata: JSON\n\n)
+ * Uses DB polling with a per-connection cache so only deltas are sent.
+ * This avoids cross-module singleton issues with an in-process event bus.
+ *
+ * - Polls features + agent runs every 500ms
+ * - Compares against cached state and emits only changes
  * - Sends heartbeat comments every 30 seconds to keep connection alive
  * - Supports optional ?runId query parameter to filter events
- * - Cleans up listeners and intervals on client disconnect
+ * - Cleans up intervals on client disconnect
  */
-import { getNotificationBus } from '../../../../../../packages/core/src/infrastructure/services/notifications/notification-bus.js';
+import { resolve } from '../../../lib/server-container.js';
+import { AgentRunStatus, SdlcLifecycle, NotificationEventType, NotificationSeverity, } from '../../../../../../packages/core/src/domain/generated/output.js';
+// Force dynamic — SSE streams must never be statically optimized or cached
+export const dynamic = 'force-dynamic';
+const POLL_INTERVAL_MS = 500;
 const HEARTBEAT_INTERVAL_MS = 30_000;
-function formatSSEEvent(event) {
-    return `event: notification\ndata: ${JSON.stringify(event)}\n\n`;
-}
-function formatHeartbeat() {
-    return ': heartbeat\n\n';
+/**
+ * Maps SdlcLifecycle values to agent graph node names so the client
+ * can derive the correct FeatureLifecyclePhase via mapPhaseNameToLifecycle().
+ */
+const LIFECYCLE_TO_NODE = {
+    [SdlcLifecycle.Analyze]: 'analyze',
+    [SdlcLifecycle.Requirements]: 'requirements',
+    [SdlcLifecycle.Research]: 'research',
+    [SdlcLifecycle.Planning]: 'plan',
+    [SdlcLifecycle.Implementation]: 'implement',
+    [SdlcLifecycle.Review]: 'merge',
+};
+const STATUS_TO_EVENT = {
+    [AgentRunStatus.running]: {
+        eventType: NotificationEventType.AgentStarted,
+        severity: NotificationSeverity.Info,
+    },
+    [AgentRunStatus.waitingApproval]: {
+        eventType: NotificationEventType.WaitingApproval,
+        severity: NotificationSeverity.Warning,
+    },
+    [AgentRunStatus.completed]: {
+        eventType: NotificationEventType.AgentCompleted,
+        severity: NotificationSeverity.Success,
+    },
+    [AgentRunStatus.failed]: {
+        eventType: NotificationEventType.AgentFailed,
+        severity: NotificationSeverity.Error,
+    },
+    [AgentRunStatus.interrupted]: {
+        eventType: NotificationEventType.AgentFailed,
+        severity: NotificationSeverity.Warning,
+    },
+    [AgentRunStatus.cancelled]: {
+        eventType: NotificationEventType.AgentFailed,
+        severity: NotificationSeverity.Warning,
+    },
+};
+/** Map agent graph node name from AgentRun.result to a phase name. */
+function resultToPhase(result) {
+    if (!result?.startsWith('node:'))
+        return undefined;
+    return result.slice(5); // "node:analyze" → "analyze"
 }
 export function GET(request) {
-    const url = new URL(request.url);
-    const runIdFilter = url.searchParams.get('runId');
-    const stream = new ReadableStream({
-        start(controller) {
-            const encoder = new TextEncoder();
-            const bus = getNotificationBus();
-            const onNotification = (event) => {
-                if (runIdFilter && event.agentRunId !== runIdFilter) {
-                    return;
-                }
-                try {
-                    controller.enqueue(encoder.encode(formatSSEEvent(event)));
-                }
-                catch {
-                    // Stream may be closed — ignore enqueue errors
-                }
-            };
-            bus.on('notification', onNotification);
-            // Heartbeat to keep connection alive
-            const heartbeatInterval = setInterval(() => {
-                try {
-                    controller.enqueue(encoder.encode(formatHeartbeat()));
-                }
-                catch {
-                    // Stream may be closed — ignore enqueue errors
+    try {
+        const url = new URL(request.url);
+        const runIdFilter = url.searchParams.get('runId');
+        const stream = new ReadableStream({
+            start(controller) {
+                const encoder = new TextEncoder();
+                // Per-connection cache: featureId → last-seen state
+                const cache = new Map();
+                let stopped = false;
+                function enqueue(text) {
+                    if (stopped)
+                        return;
+                    try {
+                        controller.enqueue(encoder.encode(text));
+                    }
+                    catch {
+                        // Stream may be closed
+                    }
                 }
-            }, HEARTBEAT_INTERVAL_MS);
-            // Cleanup on client disconnect
-            const cleanup = () => {
-                bus.removeListener('notification', onNotification);
-                clearInterval(heartbeatInterval);
-                try {
-                    controller.close();
+                function emitEvent(event) {
+                    // eslint-disable-next-line no-console
+                    console.log(`[SSE] emit: ${event.eventType} for "${event.featureName}"${event.phaseName ? ` (${event.phaseName})` : ''}`);
+                    enqueue(`event: notification\ndata: ${JSON.stringify(event)}\n\n`);
                 }
-                catch {
-                    // Stream may already be closed
+                let pollErrorCount = 0;
+                async function poll() {
+                    if (stopped)
+                        return;
+                    try {
+                        const listFeatures = resolve('ListFeaturesUseCase');
+                        const agentRunRepo = resolve('IAgentRunRepository');
+                        const phaseTimingRepo = resolve('IPhaseTimingRepository');
+                        const features = await listFeatures.execute();
+                        // Build current state for features with agent runs
+                        const entries = await Promise.all(features.map(async (feature) => {
+                            const run = feature.agentRunId
+                                ? await agentRunRepo.findById(feature.agentRunId)
+                                : null;
+                            return { feature, run };
+                        }));
+                        for (const { feature, run } of entries) {
+                            if (!run)
+                                continue;
+                            // Apply runId filter if present
+                            if (runIdFilter && run.id !== runIdFilter)
+                                continue;
+                            const prev = cache.get(feature.id);
+                            if (!prev) {
+                                // First time seeing this feature — seed cache, don't emit
+                                const completedPhases = new Set();
+                                try {
+                                    const timings = await phaseTimingRepo.findByRunId(run.id);
+                                    for (const t of timings) {
+                                        if (t.completedAt)
+                                            completedPhases.add(t.phase);
+                                    }
+                                }
+                                catch {
+                                    // Ignore timing errors
+                                }
+                                cache.set(feature.id, {
+                                    status: run.status,
+                                    lifecycle: feature.lifecycle,
+                                    completedPhases,
+                                    featureName: feature.name,
+                                });
+                                continue;
+                            }
+                            // Check for status change
+                            if (prev.status !== run.status) {
+                                prev.status = run.status;
+                                const mapping = STATUS_TO_EVENT[run.status];
+                                if (mapping) {
+                                    const phase = resultToPhase(run.result);
+                                    emitEvent({
+                                        eventType: mapping.eventType,
+                                        agentRunId: run.id,
+                                        featureId: feature.id,
+                                        featureName: feature.name,
+                                        ...(phase && { phaseName: phase }),
+                                        message: `Agent status: ${run.status}`,
+                                        severity: mapping.severity,
+                                        timestamp: new Date().toISOString(),
+                                    });
+                                }
+                            }
+                            // Check for lifecycle change (agent stays "running" but moves through phases)
+                            if (prev.lifecycle !== feature.lifecycle) {
+                                prev.lifecycle = feature.lifecycle;
+                                const nodeName = LIFECYCLE_TO_NODE[feature.lifecycle];
+                                if (nodeName) {
+                                    emitEvent({
+                                        eventType: NotificationEventType.PhaseCompleted,
+                                        agentRunId: run.id,
+                                        featureId: feature.id,
+                                        featureName: feature.name,
+                                        phaseName: nodeName,
+                                        message: `Entered ${nodeName} phase`,
+                                        severity: NotificationSeverity.Info,
+                                        timestamp: new Date().toISOString(),
+                                    });
+                                }
+                            }
+                            // Check for new phase completions
+                            try {
+                                const timings = await phaseTimingRepo.findByRunId(run.id);
+                                for (const t of timings) {
+                                    if (t.completedAt && !prev.completedPhases.has(t.phase)) {
+                                        prev.completedPhases.add(t.phase);
+                                        emitEvent({
+                                            eventType: NotificationEventType.PhaseCompleted,
+                                            agentRunId: run.id,
+                                            featureId: feature.id,
+                                            featureName: feature.name,
+                                            phaseName: t.phase,
+                                            message: `Completed ${t.phase} phase`,
+                                            severity: NotificationSeverity.Info,
+                                            timestamp: new Date().toISOString(),
+                                        });
+                                    }
+                                }
+                            }
+                            catch {
+                                // Ignore timing errors
+                            }
+                        }
+                        pollErrorCount = 0; // Reset on success
+                    }
+                    catch (error) {
+                        pollErrorCount++;
+                        // Log first few errors, then throttle to avoid spamming
+                        if (pollErrorCount <= 3 || pollErrorCount % 60 === 0) {
+                            // eslint-disable-next-line no-console
+                            console.error(`[SSE /api/agent-events] poll error #${pollErrorCount}:`, error instanceof Error ? error.message : error);
+                        }
+                    }
                 }
-            };
-            request.signal.addEventListener('abort', cleanup, { once: true });
-        },
-    });
-    return new Response(stream, {
-        headers: {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            Connection: 'keep-alive',
-        },
-    });
+                // First poll immediately, then every POLL_INTERVAL_MS
+                void poll();
+                const pollInterval = setInterval(() => void poll(), POLL_INTERVAL_MS);
+                // Heartbeat to keep connection alive
+                const heartbeatInterval = setInterval(() => {
+                    enqueue(': heartbeat\n\n');
+                }, HEARTBEAT_INTERVAL_MS);
+                // Cleanup on client disconnect
+                const cleanup = () => {
+                    stopped = true;
+                    clearInterval(pollInterval);
+                    clearInterval(heartbeatInterval);
+                    try {
+                        controller.close();
+                    }
+                    catch {
+                        // Stream may already be closed
+                    }
+                };
+                request.signal.addEventListener('abort', cleanup, { once: true });
+            },
+        });
+        return new Response(stream, {
+            headers: {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+            },
+        });
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('[SSE route] GET handler error:', error);
+        return new Response(JSON.stringify({ error: String(error) }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
 }

package/dist/src/presentation/web/app/layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/app/layout.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,6BAA6B,CAAC;AACrC,OAAO,eAAe,CAAC;AAIvB,sFAAsF;AACtF,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAEvC,eAAO,MAAM,QAAQ,EAAE,QAItB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,EACjC,QAAQ,GACT,EAAE,QAAQ,CAAC;IACV,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC,2CA0BD"}
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/app/layout.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,6BAA6B,CAAC;AACrC,OAAO,eAAe,CAAC;AAIvB,sFAAsF;AACtF,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAEvC,eAAO,MAAM,QAAQ,EAAE,QAkBtB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,EACjC,QAAQ,GACT,EAAE,QAAQ,CAAC;IACV,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC,2CA0BD"}

package/dist/src/presentation/web/app/layout.js

@@ -8,6 +8,20 @@ export const dynamic = 'force-dynamic';
 export const metadata = {
     title: 'Shep AI',
     description: 'Autonomous AI Native SDLC Platform - Automate the development cycle from idea to deploy',
+    icons: [
+        {
+            rel: 'icon',
+            url: '/favicon-light.svg',
+            type: 'image/svg+xml',
+            media: '(prefers-color-scheme: light)',
+        },
+        {
+            rel: 'icon',
+            url: '/favicon-dark.svg',
+            type: 'image/svg+xml',
+            media: '(prefers-color-scheme: dark)',
+        },
+    ],
 };
 export default function RootLayout({ children, }) {
     return (_jsxs("html", { lang: "en", suppressHydrationWarning: true, children: [_jsx("head", { children: _jsx("script", { dangerouslySetInnerHTML: {

package/dist/src/presentation/web/components/common/feature-node/derive-feature-state.d.ts

@@ -4,8 +4,9 @@
  * Derives UI node state and progress from the Feature domain model
  * and its associated AgentRun status (mirrors CLI feat ls logic).
  */
+import { NotificationEventType } from '../../../../../../packages/core/src/domain/generated/index.js';
 import type { Feature, AgentRun } from '../../../../../../packages/core/src/domain/generated/index.js';
-import type { FeatureNodeState } from './feature-node-state-config.js';
+import type { FeatureNodeState, FeatureLifecyclePhase } from './feature-node-state-config.js';
 /**
  * Derives the visual node state from a Feature and its optional AgentRun.
  *
@@ -25,4 +26,7 @@ export declare function deriveNodeState(feature: Feature, agentRun?: AgentRun |
  * Returns 100 for Maintain lifecycle, 0 if no plan.
  */
 export declare function deriveProgress(feature: Feature): number;
+/** Maps a NotificationEventType to the corresponding FeatureNodeState for optimistic UI updates. */
+export declare function mapEventTypeToState(eventType: NotificationEventType): FeatureNodeState;
+export declare function mapPhaseNameToLifecycle(phaseName: string | undefined): FeatureLifecyclePhase | undefined;
 //# sourceMappingURL=derive-feature-state.d.ts.map

package/dist/src/presentation/web/components/common/feature-node/derive-feature-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derive-feature-state.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/derive-feature-state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAEpE;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,gBAAgB,CA4C9F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAYvD"}
+{"version":3,"file":"derive-feature-state.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/derive-feature-state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAIL,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAE3F;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,gBAAgB,CA4C9F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAYvD;AAED,oGAAoG;AACpG,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,qBAAqB,GAAG,gBAAgB,CAYtF;AAYD,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,qBAAqB,GAAG,SAAS,CAGnC"}