@shepai/cli 1.183.0-pr554.2632d62 → 1.183.0-pr555.e53ab0e

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

@@ -1,94 +1,366 @@
 /**
  * SSE API Route: GET /api/agent-events
  *
- * Thin SSE adapter around `StreamAgentEventsUseCase` (clean-arch violations
- * #4, #5, #7 in spec 089). All business orchestration — delta computation,
- * crash detection, lifecycle→node mapping, interactive session polling, and
- * cloud deployment event forwarding — now lives in the use case. This route
- * only:
+ * Streams agent lifecycle notification events to connected web UI clients
+ * via Server-Sent Events (SSE).
  *
- * - Resolves the use case via DI
- * - Frames each yielded event as an SSE `data:` line
- * - Sends heartbeats every 30 s to keep the connection alive
- * - Propagates the client abort signal into the generator
+ * 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 intervals on client disconnect
  */
 import { resolve } from '../../../lib/server-container.js';
-// Force dynamic — SSE streams must never be statically optimized or cached.
+import { AgentRunStatus, InteractiveSessionStatus, SdlcLifecycle, NotificationEventType, NotificationSeverity, } from '../../../../../../packages/core/src/domain/generated/output.js';
+import { isProcessAlive } from '../../../../../../packages/core/src/infrastructure/services/process/is-process-alive.js';
+// Force dynamic — SSE streams must never be statically optimized or cached
 export const dynamic = 'force-dynamic';
+const POLL_INTERVAL_MS = 2_000;
 const HEARTBEAT_INTERVAL_MS = 30_000;
+/**
+ * Maps SdlcLifecycle values to agent graph node names so the client
+ * can derive the correct FeatureLifecyclePhase via mapPhaseNameToLifecycle().
+ */
+const LIFECYCLE_TO_NODE = {
+    [SdlcLifecycle.Started]: 'requirements',
+    [SdlcLifecycle.Analyze]: 'analyze',
+    [SdlcLifecycle.Requirements]: 'requirements',
+    [SdlcLifecycle.Research]: 'research',
+    [SdlcLifecycle.Planning]: 'plan',
+    [SdlcLifecycle.Implementation]: 'implement',
+    [SdlcLifecycle.Review]: 'merge',
+    [SdlcLifecycle.Maintain]: 'maintain',
+    [SdlcLifecycle.Blocked]: 'blocked',
+    [SdlcLifecycle.Pending]: 'pending',
+    [SdlcLifecycle.Deleting]: 'blocked',
+    [SdlcLifecycle.AwaitingUpstream]: 'merge',
+    [SdlcLifecycle.Archived]: 'archived',
+};
+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 logger = resolve('ILogger');
     try {
         const url = new URL(request.url);
-        const runIdFilter = url.searchParams.get('runId') ?? undefined;
+        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();
+                // Per-connection cache: sessionId → last-seen interactive session state
+                const sessionCache = new Map();
                 let stopped = false;
-                const enqueue = (text) => {
+                function enqueue(text) {
                     if (stopped)
                         return;
                     try {
                         controller.enqueue(encoder.encode(text));
                     }
                     catch {
-                        // Stream may already be closed.
+                        // Stream may be closed
                     }
-                };
-                const writeEvent = (event) => {
-                    if (event.kind === 'notification') {
-                        logger.debug(`[SSE] emit: ${event.event.eventType} for "${event.event.featureName}"${event.event.phaseName ? ` (${event.event.phaseName})` : ''}`);
-                        enqueue(`event: notification\ndata: ${JSON.stringify(event.event)}\n\n`);
+                }
+                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`);
+                }
+                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,
+                                    prStatus: feature.pr?.status,
+                                    prMergeable: feature.pr?.mergeable,
+                                    prCiStatus: feature.pr?.ciStatus,
+                                });
+                                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 crashed agent: status is running/pending but PID is dead
+                            const isActive = run.status === AgentRunStatus.running || run.status === AgentRunStatus.pending;
+                            if (isActive && run.pid && !prev.crashEmitted && !isProcessAlive(run.pid)) {
+                                prev.crashEmitted = true;
+                                const phase = resultToPhase(run.result);
+                                emitEvent({
+                                    eventType: NotificationEventType.AgentFailed,
+                                    agentRunId: run.id,
+                                    featureId: feature.id,
+                                    featureName: feature.name,
+                                    ...(phase && { phaseName: phase }),
+                                    message: `Agent crashed (PID ${run.pid} dead)`,
+                                    severity: NotificationSeverity.Error,
+                                    timestamp: new Date().toISOString(),
+                                });
+                            }
+                            // Check for feature name change (AI metadata generation updates name)
+                            if (prev.featureName !== feature.name) {
+                                prev.featureName = feature.name;
+                                const nodeName = LIFECYCLE_TO_NODE[feature.lifecycle] ?? 'requirements';
+                                emitEvent({
+                                    eventType: NotificationEventType.PhaseCompleted,
+                                    agentRunId: run.id,
+                                    featureId: feature.id,
+                                    featureName: feature.name,
+                                    phaseName: nodeName,
+                                    message: `Feature metadata updated`,
+                                    severity: NotificationSeverity.Info,
+                                    timestamp: new Date().toISOString(),
+                                });
+                            }
+                            // Check for lifecycle change (agent stays "running" but moves through phases)
+                            if (prev.lifecycle !== feature.lifecycle) {
+                                const prevLifecycle = prev.lifecycle;
+                                prev.lifecycle = feature.lifecycle;
+                                const nodeName = LIFECYCLE_TO_NODE[feature.lifecycle];
+                                // Emit MergeReviewReady when lifecycle transitions TO Review
+                                if (feature.lifecycle === SdlcLifecycle.Review &&
+                                    prevLifecycle !== SdlcLifecycle.Review) {
+                                    const prUrl = feature.pr?.url;
+                                    const message = prUrl
+                                        ? `Ready for merge review — PR: ${prUrl}`
+                                        : 'Ready for merge review';
+                                    emitEvent({
+                                        eventType: NotificationEventType.MergeReviewReady,
+                                        agentRunId: run.id,
+                                        featureId: feature.id,
+                                        featureName: feature.name,
+                                        phaseName: 'merge',
+                                        message,
+                                        severity: NotificationSeverity.Info,
+                                        timestamp: new Date().toISOString(),
+                                    });
+                                }
+                                else 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 PR data changes (status / mergeable / CI status)
+                            const curPrStatus = feature.pr?.status;
+                            const curMergeable = feature.pr?.mergeable;
+                            const curCiStatus = feature.pr?.ciStatus;
+                            if (curPrStatus !== prev.prStatus ||
+                                curMergeable !== prev.prMergeable ||
+                                curCiStatus !== prev.prCiStatus) {
+                                prev.prStatus = curPrStatus;
+                                prev.prMergeable = curMergeable;
+                                prev.prCiStatus = curCiStatus;
+                                const nodeName = LIFECYCLE_TO_NODE[feature.lifecycle] ?? 'merge';
+                                emitEvent({
+                                    eventType: NotificationEventType.PhaseCompleted,
+                                    agentRunId: run.id,
+                                    featureId: feature.id,
+                                    featureName: feature.name,
+                                    phaseName: nodeName,
+                                    message: curMergeable === false
+                                        ? `PR #${feature.pr?.number} has merge conflicts`
+                                        : `PR status updated`,
+                                    severity: curMergeable === false
+                                        ? NotificationSeverity.Warning
+                                        : 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
+                            }
+                        }
+                        // Poll interactive sessions for lifecycle status changes
+                        try {
+                            const sessionRepo = resolve('IInteractiveSessionRepository');
+                            const activeSessions = await sessionRepo.findAllActive();
+                            for (const session of activeSessions) {
+                                const prev = sessionCache.get(session.id);
+                                if (prev?.status !== session.status) {
+                                    sessionCache.set(session.id, { status: session.status });
+                                    const eventType = session.status === InteractiveSessionStatus.booting
+                                        ? 'interactive_session_booting'
+                                        : session.status === InteractiveSessionStatus.ready
+                                            ? 'interactive_session_ready'
+                                            : session.status === InteractiveSessionStatus.error
+                                                ? 'interactive_session_error'
+                                                : 'interactive_session_stopped';
+                                    const payload = {
+                                        type: eventType,
+                                        sessionId: session.id,
+                                        featureId: session.featureId,
+                                    };
+                                    enqueue(`event: interactive_session\ndata: ${JSON.stringify(payload)}\n\n`);
+                                }
+                            }
+                            // Emit stopped/error events for sessions that disappeared from active list
+                            for (const [sessionId, cached] of sessionCache) {
+                                if ((cached.status === InteractiveSessionStatus.booting ||
+                                    cached.status === InteractiveSessionStatus.ready) &&
+                                    !activeSessions.find((s) => s.id === sessionId)) {
+                                    // Session no longer active — fetch to get final status
+                                    const session = await sessionRepo.findById(sessionId);
+                                    if (session) {
+                                        sessionCache.set(sessionId, { status: session.status });
+                                        const eventType = session.status === InteractiveSessionStatus.error
+                                            ? 'interactive_session_error'
+                                            : 'interactive_session_stopped';
+                                        const payload = {
+                                            type: eventType,
+                                            sessionId: session.id,
+                                            featureId: session.featureId,
+                                        };
+                                        enqueue(`event: interactive_session\ndata: ${JSON.stringify(payload)}\n\n`);
+                                    }
+                                    else {
+                                        sessionCache.delete(sessionId);
+                                    }
+                                }
+                            }
+                        }
+                        catch {
+                            // Ignore interactive session poll errors to not affect main polling
+                        }
+                        pollErrorCount = 0; // Reset on success
                     }
-                    else {
-                        const payload = {
-                            type: event.type,
-                            sessionId: event.sessionId,
-                            featureId: event.featureId,
-                        };
-                        enqueue(`event: interactive_session\ndata: ${JSON.stringify(payload)}\n\n`);
+                    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);
+                        }
                     }
-                };
-                const abortController = new AbortController();
+                }
+                // 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 = () => {
-                    if (stopped)
-                        return;
                     stopped = true;
-                    abortController.abort();
+                    clearInterval(pollInterval);
                     clearInterval(heartbeatInterval);
                     try {
                         controller.close();
                     }
                     catch {
-                        // Stream may already be closed.
+                        // Stream may already be closed
                     }
                 };
-                // Heartbeat to keep connection alive.
-                const heartbeatInterval = setInterval(() => {
-                    enqueue(': heartbeat\n\n');
-                }, HEARTBEAT_INTERVAL_MS);
                 request.signal.addEventListener('abort', cleanup, { once: true });
-                // Kick off the use-case generator — fire and forget; completion is
-                // driven entirely by the abort signal.
-                void (async () => {
-                    try {
-                        const streamUseCase = resolve('StreamAgentEventsUseCase');
-                        for await (const event of streamUseCase.execute({
-                            runIdFilter,
-                            signal: abortController.signal,
-                        })) {
-                            if (stopped)
-                                break;
-                            writeEvent(event);
-                        }
-                    }
-                    catch (error) {
-                        logger.error(`[SSE /api/agent-events] generator error: ${error instanceof Error ? error.message : String(error)}`);
-                    }
-                    finally {
-                        cleanup();
-                    }
-                })();
             },
         });
         return new Response(stream, {
@@ -100,7 +372,8 @@ export function GET(request) {
         });
     }
     catch (error) {
-        logger.error(`[SSE route] GET handler error: ${error instanceof Error ? error.message : String(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/api/applications/[id]/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../../src/presentation/web/app/api/applications/[id]/route.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAQ3C,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAEvC,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjC;AAED,wBAAsB,GAAG,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CA0C/F"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../../src/presentation/web/app/api/applications/[id]/route.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAO3C,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAEvC,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjC;AAED,wBAAsB,GAAG,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAwC/F"}

package/dist/src/presentation/web/app/api/applications/[id]/route.js

@@ -8,7 +8,6 @@
  */
 import { NextResponse } from 'next/server';
 import { resolve } from '../../../../lib/server-container.js';
-import { featureIdForApplication } from '../../../../../../../packages/core/src/domain/shared/feature-id.js';
 export const dynamic = 'force-dynamic';
 export async function GET(_request, { params }) {
     try {
@@ -21,9 +20,7 @@ export async function GET(_request, { params }) {
         let initialChatState;
         try {
             const getChatState = resolve('GetInteractiveChatStateUseCase');
-            initialChatState = await getChatState.execute({
-                featureId: featureIdForApplication(application.id),
-            });
+            initialChatState = await getChatState.execute({ featureId: `app-${application.id}` });
         }
         catch {
             initialChatState = undefined;

package/dist/src/presentation/web/app/api/deployment-logs/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/app/api/deployment-logs/route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAUH,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAIvC,wBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAyF9C"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/app/api/deployment-logs/route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AASH,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAIvC,wBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAuF9C"}

package/dist/src/presentation/web/app/api/deployment-logs/route.js

@@ -84,10 +84,8 @@ export function GET(request) {
         });
     }
     catch (error) {
-        const logger = resolve('ILogger');
-        logger.error('[SSE route] GET /api/deployment-logs error', {
-            error: error instanceof Error ? error.message : String(error),
-        });
+        // eslint-disable-next-line no-console
+        console.error('[SSE route] GET /api/deployment-logs error:', error);
         return new Response(JSON.stringify({ error: String(error) }), {
             status: 500,
             headers: { 'Content-Type': 'application/json' },

package/dist/src/presentation/web/app/build-graph-nodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-graph-nodes.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/app/build-graph-nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,QAAQ,EACR,WAAW,EACZ,MAAM,sCAAsC,CAAC;AAU9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAG1C,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,uEAAuE;IACvE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6EAA6E;IAC7E,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,qEAAqE;IACrE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,0FAA0F;IAC1F,WAAW,CAAC,EAAE,GAAG,CACf,MAAM,EACN;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CACzF,CAAC;IACF,0DAA0D;IAC1D,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,YAAY,CAAC,CAAC;IAChE,0DAA0D;IAC1D,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;CAC9B;AAED,wBAAgB,eAAe,CAC7B,YAAY,EAAE,UAAU,EAAE,EAC1B,gBAAgB,EAAE,cAAc,EAAE,EAClC,OAAO,CAAC,EAAE,sBAAsB,GAC/B;IAAE,KAAK,EAAE,cAAc,EAAE,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAwH5C"}
+{"version":3,"file":"build-graph-nodes.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/web/app/build-graph-nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,QAAQ,EACR,WAAW,EACZ,MAAM,sCAAsC,CAAC;AAS9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAG1C,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,uEAAuE;IACvE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6EAA6E;IAC7E,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,qEAAqE;IACrE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,0FAA0F;IAC1F,WAAW,CAAC,EAAE,GAAG,CACf,MAAM,EACN;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CACzF,CAAC;IACF,0DAA0D;IAC1D,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,YAAY,CAAC,CAAC;IAChE,0DAA0D;IAC1D,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;CAC9B;AAED,wBAAgB,eAAe,CAC7B,YAAY,EAAE,UAAU,EAAE,EAC1B,gBAAgB,EAAE,cAAc,EAAE,EAClC,OAAO,CAAC,EAAE,sBAAsB,GAC/B;IAAE,KAAK,EAAE,cAAc,EAAE,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAwH5C"}

package/dist/src/presentation/web/app/build-graph-nodes.js

@@ -2,7 +2,6 @@ import { AgentRunStatus } from '../../../../packages/core/src/domain/generated/o
 import { deriveNodeState, deriveProgress, deriveLifecycle, } from '../components/common/feature-node/derive-feature-state.js';
 import { isProcessAlive } from '../../../../packages/core/src/infrastructure/services/process/is-process-alive.js';
 import { computeWorktreePath } from '../../../../packages/core/src/infrastructure/services/ide-launchers/compute-worktree-path.js';
-import { featureIdForApplication } from '../../../../packages/core/src/domain/shared/feature-id.js';
 export function buildGraphNodes(repositories, featuresWithRuns, options) {
     // Normalize path separators so Windows backslash paths match forward-slash paths
     const normalizePath = (p) => p.replace(/\\/g, '/');
@@ -79,7 +78,7 @@ export function buildGraphNodes(repositories, featuresWithRuns, options) {
     // Add application nodes (independent — no edges)
     if (options?.applications) {
         for (const app of options.applications) {
-            const appNodeId = featureIdForApplication(app.id);
+            const appNodeId = `app-${app.id}`;
             nodes.push({
                 id: appNodeId,
                 type: 'applicationNode',

package/dist/src/presentation/web/app/plugins/page.d.ts

@@ -0,0 +1,4 @@
+/** Skip static pre-rendering since we need runtime DI container. */
+export declare const dynamic = "force-dynamic";
+export default function PluginsPage(): Promise<import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=page.d.ts.map

package/dist/src/presentation/web/app/plugins/page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/plugins/page.tsx"],"names":[],"mappings":"AASA,oEAAoE;AACpE,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAEvC,wBAA8B,WAAW,qDAuBxC"}

package/dist/src/presentation/web/app/plugins/page.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { resolve } from '../../lib/server-container.js';
+import { PluginsPageClient } from './plugins-page-client.js';
+/** Skip static pre-rendering since we need runtime DI container. */
+export const dynamic = 'force-dynamic';
+export default async function PluginsPage() {
+    let plugins = [];
+    let catalog = [];
+    try {
+        const listUseCase = resolve('ListPluginsUseCase');
+        plugins = await listUseCase.execute();
+    }
+    catch {
+        // DI container may not be available during build
+    }
+    try {
+        const catalogUseCase = resolve('GetPluginCatalogUseCase');
+        catalog = await catalogUseCase.execute();
+    }
+    catch {
+        // DI container may not be available during build
+    }
+    return (_jsx("div", { className: "flex h-full flex-col p-6", children: _jsx(PluginsPageClient, { plugins: plugins, catalog: catalog }) }));
+}

package/dist/src/presentation/web/app/plugins/plugins-page-client.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from '../../../../../packages/core/src/domain/generated/output.js';
+import type { CatalogEntryWithStatus } from '../../../../../packages/core/src/application/use-cases/plugins/get-plugin-catalog.use-case.js';
+export interface PluginsPageClientProps {
+    plugins: Plugin[];
+    catalog: CatalogEntryWithStatus[];
+}
+export declare function PluginsPageClient({ plugins, catalog }: PluginsPageClientProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=plugins-page-client.d.ts.map

package/dist/src/presentation/web/app/plugins/plugins-page-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins-page-client.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/plugins/plugins-page-client.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wEAAwE,CAAC;AAErH,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,sBAAsB,EAAE,CAAC;CACnC;AAED,wBAAgB,iBAAiB,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,sBAAsB,2CAuF7E"}

package/dist/src/presentation/web/app/plugins/plugins-page-client.js

@@ -0,0 +1,61 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from 'react';
+import { useRouter } from 'next/navigation';
+import { Plug } from 'lucide-react';
+import { toast } from 'sonner';
+import { PageHeader } from '../../components/common/page-header/index.js';
+import { PluginList } from '../../components/common/plugin-list/index.js';
+import { PluginCatalog } from '../../components/common/plugin-catalog/index.js';
+import { Tabs, TabsContent, TabsList, TabsTrigger } from '../../components/ui/tabs.js';
+import { addPlugin } from '../actions/add-plugin.js';
+import { removePlugin } from '../actions/remove-plugin.js';
+import { togglePlugin } from '../actions/toggle-plugin.js';
+import { checkPluginHealth } from '../actions/check-plugin-health.js';
+export function PluginsPageClient({ plugins, catalog }) {
+    const router = useRouter();
+    const [activeTab, setActiveTab] = useState(plugins.length > 0 ? 'installed' : 'catalog');
+    const handleToggle = useCallback(async (pluginName, enabled) => {
+        const result = await togglePlugin(pluginName, enabled);
+        if (result.error) {
+            toast.error(result.error);
+        }
+        else {
+            toast.success(`${pluginName} ${enabled ? 'enabled' : 'disabled'}`);
+            router.refresh();
+        }
+    }, [router]);
+    const handleRemove = useCallback(async (pluginName) => {
+        const result = await removePlugin(pluginName);
+        if (result.error) {
+            toast.error(result.error);
+        }
+        else {
+            toast.success(`${pluginName} removed`);
+            router.refresh();
+        }
+    }, [router]);
+    const handleCheckHealth = useCallback(async (pluginName) => {
+        const result = await checkPluginHealth(pluginName);
+        if (result.error) {
+            toast.error(result.error);
+        }
+        else if (result.results?.[0]) {
+            const health = result.results[0];
+            toast.info(`${pluginName}: ${health.status} — ${health.message}`);
+            router.refresh();
+        }
+    }, [router]);
+    const handleInstall = useCallback(async (pluginName) => {
+        const result = await addPlugin(pluginName);
+        if (result.error) {
+            toast.error(result.error);
+        }
+        else {
+            toast.success(`${pluginName} installed`);
+            setActiveTab('installed');
+            router.refresh();
+        }
+    }, [router]);
+    return (_jsxs("div", { className: "flex flex-col gap-6", children: [_jsx(PageHeader, { title: "Plugins", description: "Manage AI-native tool plugins for agentic workflows", children: _jsx(Plug, { className: "text-muted-foreground h-5 w-5" }) }), _jsxs(Tabs, { value: activeTab, onValueChange: setActiveTab, children: [_jsxs(TabsList, { children: [_jsxs(TabsTrigger, { value: "installed", children: ["Installed", plugins.length > 0 ? ` (${plugins.length})` : ''] }), _jsx(TabsTrigger, { value: "catalog", children: "Catalog" })] }), _jsx(TabsContent, { value: "installed", children: _jsx(PluginList, { plugins: plugins, onToggle: handleToggle, onRemove: handleRemove, onCheckHealth: handleCheckHealth }) }), _jsx(TabsContent, { value: "catalog", children: _jsx(PluginCatalog, { catalog: catalog, onInstall: handleInstall }) })] })] }));
+}

package/dist/src/presentation/web/components/common/application-node/application-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application-node.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/application-node/application-node.tsx"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAMrE,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,mBAAmB,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,2CAwZA"}
+{"version":3,"file":"application-node.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/application-node/application-node.tsx"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAMrE,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,mBAAmB,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,2CAwZA"}

package/dist/src/presentation/web/components/common/application-node/application-node.js

@@ -11,7 +11,6 @@ import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '../../
 import { useTurnStatus } from '../../../hooks/turn-statuses-provider.js';
 import { useDeployAction } from '../../../hooks/use-deploy-action.js';
 import { DeploymentState } from '../../../../../../packages/core/src/domain/generated/output.js';
-import { featureIdForApplication } from '../../../../../../packages/core/src/domain/shared/feature-id.js';
 import { deriveAppLiveStatus } from '../../../lib/derive-app-status.js';
 /** Preview slot height. Roomier than the old 120px to give the live
  *  iframe / start-preview CTA more presence on the canvas. */
@@ -27,7 +26,7 @@ export function ApplicationNode({ data, selected, }) {
     // Live session turn status from the global SSE subscription. The
     // scope key is `app-<id>` — same key used everywhere else the
     // application's chat is referenced.
-    const turnStatus = useTurnStatus(featureIdForApplication(data.id));
+    const turnStatus = useTurnStatus(`app-${data.id}`);
     // Shared dev-server deploy state — one per card. Subscribes to the
     // `DeploymentStatusProvider` which is SSR-seeded in the dashboard
     // layout from `ListDeploymentsUseCase`, so running apps render as