@vibesdotdev/pm 0.0.0-stage → 1.0.0-rc.2

package/dist/tui/pm-dashboard.impl.consumer.js

@@ -0,0 +1,839 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { formatPMActionError as formatActionError } from "../daemon/rpc-result.js";
+/**
+ * PM Dashboard — tui/app implementation (consumer)
+ *
+ * Two-mode dashboard: list mode (Processes/Resources tabs) and log mode
+ * (filterable process log viewer). All state via useTuiState and all daemon
+ * access through the runtime-resolved pm/client context, on the runtime the
+ * TUI host hands its apps (`useTuiRuntime`). No custom hooks, no context
+ * providers of its own, no studio imports.
+ *
+ * Spec: docs/architecture/tui-page-specs/pm.md — a subtitle, one glance line,
+ * and a process table are the whole surface (mirroring platform-web's
+ * `/processes`); facts/hints ride the screen-status contract, never a
+ * free-printed footer.
+ *
+ * Cross-fence note: this surface names itself once, in the page header
+ * ("PM Dashboard · /pm"). The glance line below is just the live counts —
+ * it does NOT restate the route name/path back to the user (that
+ * self-reference was retired). E2e assertions in
+ * `tests/tui-e2e/terminal-web/studio-web.spec.ts` were updated to key off the
+ * real header instead.
+ */
+import { useState, useEffect, useCallback, useRef } from 'react';
+import * as z from 'zod/v4';
+import { getLogger } from '@vibesdotdev/logging';
+import { valueFreeFailure } from '@vibesdotdev/kernel';
+import { DSStatus, DSText, Panel, DSScrollArea, DSSearchSelect, HStack, VStack, Spacer, useTheme, useTuiRuntime, useTuiState } from '@vibesdotdev/tui';
+import { useKeyboardLayer } from '@vibesdotdev/tui/input';
+import { Tabs } from '@vibesdotdev/tui/components/navigation';
+import { useContributeScreenStatus } from '@vibesdotdev/tui/shell';
+import { derivePMWorkspaceDiagnostics } from '@vibesdotdev/pm/schemas/tui-state';
+import { ErrorDetailsPanel } from "./components/index.js";
+import { pmProcessesStateKey, pmStatusStateKey } from "./pm-state-keys.js";
+import { attempt } from "../utils/attempt.js";
+// `<text>` is an OpenTUI JSX intrinsic. Forwarding `OTTextProps` directly to
+// it lets TS resolve the IntrinsicElements key without an `any` escape — the
+// previous `OTTextTag = 'text'` indirection lost that information.
+const OTText = (props) => _jsx("text", { ...props });
+// Helpers
+function statusColor(status, theme) {
+    const { base: dsBase, colors: dsColors } = theme;
+    switch (status) {
+        case 'running':
+        case 'pass':
+        case 'completed':
+            return dsColors.success.solid;
+        case 'stopped':
+        case 'not-started':
+            return dsBase.mutedForeground;
+        case 'errored':
+        case 'crashed':
+        case 'fail':
+            return dsColors.danger.solid;
+        case 'starting':
+        case 'stopping':
+        case 'waiting':
+            return dsColors.warning.solid;
+        default:
+            return dsBase.mutedForeground;
+    }
+}
+function resourceStatusColor(status, theme) {
+    const { base: dsBase, colors: dsColors } = theme;
+    switch (status) {
+        case 'ready':
+            return dsColors.success.solid;
+        case 'creating':
+        case 'updating':
+        case 'stopping':
+        case 'deleting':
+            return dsColors.warning.solid;
+        case 'stopped':
+        case 'missing':
+            return dsBase.mutedForeground;
+        case 'error':
+            return dsColors.danger.solid;
+        default:
+            return dsBase.mutedForeground;
+    }
+}
+function formatUptime(startedAt) {
+    if (!startedAt)
+        return '—';
+    const start = new Date(startedAt);
+    const ms = Date.now() - start.getTime();
+    if (ms < 0)
+        return '—';
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    const hours = Math.floor(seconds / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    return `${hours}h ${mins}m`;
+}
+// Truncate on a word boundary only — a mid-word cut reads as a defect.
+function truncateWords(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    const slice = value.slice(0, maxLength);
+    const cut = slice.lastIndexOf(' ');
+    const kept = (cut > maxLength * 0.5 ? slice.slice(0, cut) : slice).trimEnd();
+    return `${kept}…`;
+}
+function routeStateText(routeState, key) {
+    const value = z.string().safeParse(routeState?.[key]);
+    if (!value.success)
+        return null;
+    const trimmed = value.data.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function pluralize(count, singular, plural = `${singular}s`) {
+    return `${count} ${count === 1 ? singular : plural}`;
+}
+/**
+ * Cross-surface handoff notice: another Studio route (code-sessions, Autoloop,
+ * Workbench) sent the user here with context. Real, wanted content — not
+ * chrome — so it stays, one panel, only rendered when a handoff is present.
+ * The workspace-scope note below it is a plain-language stand-in for the
+ * killed dev-diagnostics band that used to report the same cwd-based process
+ * match in raw operator terms: same underlying scoping data
+ * (`derivePMWorkspaceDiagnostics`), one reworded sentence instead of a whole
+ * second band.
+ */
+function PMRouteContextBand({ routeState, diagnostics, compact }) {
+    const theme = useTheme();
+    const { base: dsBase, colors: dsColors } = theme;
+    const title = routeStateText(routeState, 'routeNoticeTitle');
+    const body = routeStateText(routeState, 'routeNoticeBody');
+    const correlationId = routeStateText(routeState, 'sourceCorrelationId');
+    if (!title && !body && !correlationId)
+        return null;
+    const summary = body ?? 'This PM route was opened by another Studio surface.';
+    const limit = compact ? 96 : 168;
+    const visibleCorrelation = correlationId ? truncateWords(correlationId, limit) : null;
+    const scopeNote = diagnostics && diagnostics.scopeApplied
+        ? `${pluralize(diagnostics.matchedProcesses.length, 'process', 'processes')} of ${diagnostics.totalProcessCount} match this workspace.`
+        : diagnostics
+            ? 'No processes match this workspace — showing everything.'
+            : null;
+    return (_jsxs(Panel, { padding: "xs", gap: "xs", status: "info", children: [_jsxs(HStack, { gap: 1, children: [_jsx(DSStatus, { status: "info", compact: true }), _jsx(OTText, { fg: dsColors.info.solid, bold: true, children: "PM handoff context" }), _jsx(Spacer, {}), _jsx(OTText, { fg: dsBase.mutedForeground, children: title ?? 'Studio context' })] }), visibleCorrelation ? (_jsxs(OTText, { fg: dsBase.mutedForeground, children: ["Context ", visibleCorrelation] })) : null, _jsx(OTText, { fg: dsBase.mutedForeground, children: truncateWords(summary, limit) }), scopeNote ? _jsx(OTText, { fg: dsBase.mutedForeground, children: scopeNote }) : null] }));
+}
+function healthIndicator(health) {
+    switch (health) {
+        case 'healthy':
+            return '● healthy';
+        case 'unhealthy':
+            return '○ unhealthy';
+        case 'unknown':
+            return '◌ unknown';
+        case 'no-check':
+            return '— no check';
+        default:
+            return '·';
+    }
+}
+function healthColor(health, theme) {
+    const { base: dsBase, colors: dsColors } = theme;
+    switch (health) {
+        case 'healthy':
+            return dsColors.success.solid;
+        case 'unhealthy':
+            return dsColors.danger.solid;
+        default:
+            return dsBase.mutedForeground;
+    }
+}
+/** Overall daemon health word — same healthy/degraded/down/unknown vocabulary
+ * as `DaemonHealthCard`, expressed inline in the one glance line instead of a
+ * card (the region table asks for one line, not a tile). */
+function daemonHealthWord(args) {
+    if (!args.hasLoadedMonitorState)
+        return 'unknown';
+    if (args.hasMonitorError)
+        return args.connected ? 'degraded' : 'down';
+    if (args.connected && args.pmAvailable)
+        return 'healthy';
+    if (args.connected)
+        return 'degraded';
+    return 'unknown';
+}
+function logLineColor(line, theme) {
+    const { base: dsBase, colors: dsColors } = theme;
+    if (line.includes('ERROR') || line.includes('error'))
+        return dsColors.danger.solid;
+    if (line.includes('WARN') || line.includes('warn'))
+        return dsColors.warning.solid;
+    if (line.includes('INFO') || line.includes('info'))
+        return dsColors.info.solid;
+    if (line.includes('DEBUG') || line.includes('debug'))
+        return dsBase.mutedForeground;
+    if (line.startsWith('===') || line.startsWith('---'))
+        return dsColors.primary.solid;
+    return dsBase.foreground;
+}
+function ColumnText({ value, width, fg, bold = false }) {
+    const { base: dsBase } = useTheme();
+    return (_jsx(VStack, { style: { width, overflow: 'hidden' }, children: _jsx(OTText, { content: truncateWords(value, width), fg: fg ?? dsBase.foreground, bold: bold }) }));
+}
+function ProcessTable({ rows, selectedId, onSelect }) {
+    const theme = useTheme();
+    const { base: dsBase, colors: dsColors } = theme;
+    if (rows.length === 0) {
+        return _jsx(PMEmptyState, { kind: "processes" });
+    }
+    return (_jsxs(VStack, { grow: true, style: { minHeight: 0 }, children: [_jsxs(HStack, { style: {
+                    border: ['bottom'],
+                    borderColor: dsBase.border,
+                    paddingLeft: 1,
+                    paddingRight: 1,
+                    flexShrink: 0
+                }, children: [_jsx(ColumnText, { value: "", width: 2 }), _jsx(ColumnText, { value: "Name", width: 28, bold: true }), _jsx(ColumnText, { value: "Status", width: 12, bold: true }), _jsx(ColumnText, { value: "Health", width: 14, bold: true }), _jsx(ColumnText, { value: "PID", width: 8, bold: true }), _jsx(ColumnText, { value: "Uptime", width: 10, bold: true })] }), _jsx(DSScrollArea, { style: { flexGrow: 1, minHeight: 0 }, children: _jsx(VStack, { children: rows.map((row) => {
+                        const selected = row.id === selectedId;
+                        return (_jsxs(HStack, { style: {
+                                backgroundColor: selected ? dsBase.muted : undefined,
+                                paddingLeft: 1,
+                                paddingRight: 1
+                            }, onMouseUp: () => onSelect(row), children: [_jsx(ColumnText, { value: selected ? '>' : '', width: 2, fg: selected ? dsColors.primary.solid : dsBase.mutedForeground }), _jsx(ColumnText, { value: row.name, width: 28, fg: selected ? dsColors.primary.solid : dsBase.foreground }), _jsx(ColumnText, { value: row.status, width: 12, fg: statusColor(row.status, theme) }), _jsx(ColumnText, { value: row.health, width: 14, fg: row.healthColor }), _jsx(ColumnText, { value: row.pid, width: 8, fg: dsBase.mutedForeground }), _jsx(ColumnText, { value: row.uptime, width: 10, fg: dsBase.mutedForeground })] }, row.id));
+                    }) }) })] }));
+}
+function ResourceTable({ rows }) {
+    const theme = useTheme();
+    const { base: dsBase } = theme;
+    if (rows.length === 0) {
+        return _jsx(PMEmptyState, { kind: "resources" });
+    }
+    return (_jsxs(VStack, { grow: true, style: { minHeight: 0 }, children: [_jsxs(HStack, { style: {
+                    border: ['bottom'],
+                    borderColor: dsBase.border,
+                    paddingLeft: 1,
+                    paddingRight: 1,
+                    flexShrink: 0
+                }, children: [_jsx(ColumnText, { value: "Name", width: 30, bold: true }), _jsx(ColumnText, { value: "Status", width: 12, bold: true }), _jsx(ColumnText, { value: "Liveness/Fleet", width: 32, bold: true })] }), _jsx(DSScrollArea, { style: { flexGrow: 1, minHeight: 0 }, children: _jsx(VStack, { children: rows.map((row) => (_jsxs(HStack, { style: {
+                            paddingLeft: 1,
+                            paddingRight: 1
+                        }, children: [_jsx(ColumnText, { value: row.name, width: 30 }), _jsx(ColumnText, { value: row.status, width: 12, fg: resourceStatusColor(row.status, theme) }), _jsx(ColumnText, { value: row.type || '—', width: 32, fg: dsBase.mutedForeground })] }, row.id))) }) })] }));
+}
+function PMEmptyState({ kind }) {
+    const theme = useTheme();
+    const { base: dsBase, colors: dsColors } = theme;
+    const isProcesses = kind === 'processes';
+    const title = isProcesses ? 'No managed processes' : 'No managed resources';
+    const detail = isProcesses
+        ? 'No process configs are registered for this workspace yet.'
+        : 'No resource providers have reported containers, tunnels, slices, or services yet.';
+    const action = isProcesses
+        ? 'Run a workspace preset or add a PM process config to populate this view.'
+        : 'Resources appear after PM discovers backing services for the active workflow.';
+    return (_jsxs(Panel, { padding: "sm", gap: "xs", status: "info", children: [_jsxs(HStack, { gap: 1, children: [_jsx(DSStatus, { status: "info", compact: true }), _jsx(OTText, { content: `${isProcesses ? 'idle' : 'empty'} · ${title}`, fg: dsColors.primary.solid })] }), _jsx(OTText, { fg: dsBase.mutedForeground, children: detail }), _jsx(OTText, { fg: dsBase.foreground, children: action })] }));
+}
+function footerToneColor(tone, theme) {
+    const { base: dsBase, colors: dsColors } = theme;
+    switch (tone) {
+        case 'success':
+            return dsColors.success.solid;
+        case 'warning':
+            return dsColors.warning.solid;
+        case 'danger':
+            return dsColors.danger.solid;
+        case 'muted':
+            return dsBase.mutedForeground;
+    }
+}
+/** Per-action result (restart/stop/start succeeded or failed) — real,
+ * transient content, not a keybind footer. Rides inline in the page body
+ * (matching code-sessions' inline command-run feedback), never a free-printed
+ * status/keybind line. */
+function ActionFeedbackLine({ feedback }) {
+    const theme = useTheme();
+    const { base: dsBase } = theme;
+    return (_jsx(HStack, { style: {
+            border: ['top'],
+            borderColor: dsBase.border,
+            paddingLeft: 1,
+            paddingRight: 1,
+            paddingTop: 1,
+            flexShrink: 0
+        }, children: _jsx(OTText, { content: feedback.message, fg: footerToneColor(feedback.tone, theme) }) }));
+}
+/** The text of a failure, for the line a user reads. */
+function failureText(failure) {
+    return failure instanceof Error ? failure.message : failure.description;
+}
+function processLabel(process) {
+    return process?.config?.name ?? process?.id ?? 'process';
+}
+const TERMINAL_TASK_STATUSES = new Set(['pass', 'fail', 'completed']);
+function startActionVerb(process) {
+    return process?.status && TERMINAL_TASK_STATUSES.has(process.status) ? 'Rerun' : 'Start';
+}
+function startBlockedReason(process) {
+    const status = process?.status ?? 'unknown';
+    if (status === 'running')
+        return 'already running';
+    if (status === 'starting' || status === 'stopping')
+        return `process is ${status}`;
+    if (status === 'waiting') {
+        const blockers = process?.config?.requiresPass?.filter(Boolean) ?? [];
+        return blockers.length > 0
+            ? `waiting on ${blockers.join(', ')}`
+            : 'waiting on required task dependency';
+    }
+    return null;
+}
+// Process/status filter — collapsed from the old 9-permanent-chip row to one
+// cyclable affordance (spec: "collapse to one 'Filter' affordance; don't
+// render over an empty table").
+const PROCESS_FILTERS = ['all', 'running', 'stopped', 'attention'];
+const PROCESS_FILTER_LABELS = {
+    all: 'All',
+    running: 'Running',
+    stopped: 'Stopped',
+    attention: 'Attention'
+};
+function matchesProcessFilter(status, filter) {
+    if (filter === 'all')
+        return true;
+    if (filter === 'running')
+        return status === 'running';
+    if (filter === 'stopped')
+        return status === 'stopped' || status === 'not-started';
+    if (filter === 'attention')
+        return status === 'errored' || status === 'crashed' || status === 'fail';
+    return true;
+}
+const LOG_TAIL_LINES = 20;
+/** Retained for the daemon-side liveness-profile mutation only (see the
+ * `f` binding below) — the old dev-loop status band this once powered is
+ * killed per the pm.md spec (dev-jargon-as-user-copy), but a standing e2e
+ * proof still exercises the real mutation through this key, so the
+ * capability stays wired without a user-facing hint. */
+const PMLivenessStateSchema = z.object({
+    profile: z.string().optional(),
+    env: z.string().optional(),
+    proxy: z.unknown().optional(),
+    scope: z.string().optional(),
+    note: z.string().optional()
+});
+/** What the daemon answers to a liveness mutation: the now-active profile, and its proxy. */
+const LivenessMutationResultSchema = z.object({
+    active: PMLivenessStateSchema.optional(),
+    proxy: z.unknown().optional()
+});
+export function resolveFullLivenessProfile(activeLiveness) {
+    return activeLiveness?.env ? 'fleet-mutable' : 'local-hmr';
+}
+function PMDashboardApp({ dimensions, onExit, routeState }) {
+    const theme = useTheme();
+    const { base: dsBase, colors: dsColors } = theme;
+    // The runtime the TUI host hands its apps, typed (`TuiAppProps.runtime` is
+    // `unknown` at the kind boundary). Its lifecycle ticks the refreshes (RC07),
+    // its `pm/client` context is the daemon, and its Logging records failures
+    // (C083a). Mounted without one, it fails typed (`runtime-unavailable`).
+    const runtime = useTuiRuntime();
+    // --- State from tui/state ---
+    const processData = useTuiState(pmProcessesStateKey);
+    const statusData = useTuiState(pmStatusStateKey);
+    // --- PMClient ---
+    const clientRef = useRef(null);
+    // A pm/client that failed to resolve is shown (the daemon tile and the
+    // readiness band), never read as "no daemon".
+    const [clientError, setClientError] = useState(null);
+    const resolveClient = useCallback(async () => {
+        if (clientRef.current)
+            return clientRef.current;
+        const resolved = await attempt(() => runtime.context('pm/client'));
+        if (!resolved.ok) {
+            clientRef.current = null;
+            setClientError(`pm/client did not resolve: ${failureText(resolved.failure)}`);
+            return null;
+        }
+        clientRef.current = resolved.value;
+        setClientError(null);
+        return resolved.value;
+    }, [runtime]);
+    // Single resolution path: resolveClient lazily resolves and caches into clientRef.
+    // This effect only invalidates that cache when the runtime identity changes (or on
+    // unmount) so a stale client is never served — no redundant eager prime.
+    useEffect(() => {
+        clientRef.current = null;
+        return () => {
+            clientRef.current = null;
+        };
+    }, [runtime]);
+    // --- Liveness profile (daemon-mutation only — no visible band; see the
+    // module comment on PMLivenessState) ---
+    const [activeLiveness, setActiveLiveness] = useState(null);
+    useEffect(() => {
+        const fetchLiveness = async () => {
+            const client = await resolveClient();
+            if (!client)
+                return;
+            const logger = getLogger('pm.tui.dashboard', runtime);
+            const fetched = await attempt(() => client.getActiveLivenessProfile());
+            if (!fetched.ok) {
+                logger.debug('failed to fetch liveness profile', { failure: valueFreeFailure(fetched.failure) });
+            }
+            setActiveLiveness(fetched.ok ? (fetched.value ?? null) : null);
+        };
+        fetchLiveness();
+        // The TUI host's lifecycle tick (RC07), as the pm TUI state impls use;
+        // poll: the daemon publishes no liveness-change event to this client.
+        return runtime.lifecycle.interval(() => void fetchLiveness(), 4000);
+    }, [resolveClient, runtime]);
+    // --- View state ---
+    const [activeTab, setActiveTab] = useState('processes');
+    const [viewMode, setViewMode] = useState('list');
+    const [selectedProcessId, setSelectedProcessId] = useState(null);
+    const [logContent, setLogContent] = useState('');
+    const [highlightedProcessId, setHighlightedProcessId] = useState(null);
+    const [processFilter, setProcessFilter] = useState('all');
+    const [actionFeedback, setActionFeedback] = useState(null);
+    // --- Derived data ---
+    const allProcesses = processData?.processes ?? [];
+    const workspaceDiagnostics = derivePMWorkspaceDiagnostics(routeStateText(routeState, 'sourceWorkspacePath'), allProcesses);
+    const processes = allProcesses.filter((proc) => matchesProcessFilter(proc.status, processFilter));
+    const resources = processData?.resources ?? [];
+    const connected = processData?.connected ?? false;
+    const pmAvailable = statusData?.pmAvailable ?? false;
+    // A daemon-availability probe that threw (from either poll) — distinct from a clean
+    // "daemon not running" — so both the readiness band and the daemon tile can surface it.
+    const daemonConnectionError = processData?.connectionError ?? statusData?.connectionError ?? clientError ?? null;
+    const hasMonitorError = Boolean(processData?.processesError ||
+        processData?.resourcesError ||
+        daemonConnectionError);
+    const hasLoadedMonitorState = Boolean(processData || statusData);
+    const highlightedProcess = (highlightedProcessId ? processes.find((process) => process.id === highlightedProcessId) : null) ??
+        processes[0] ??
+        null;
+    const highlightedProcessIndex = highlightedProcess
+        ? processes.findIndex((process) => process.id === highlightedProcess.id)
+        : -1;
+    // --- Process table data ---
+    const processRows = processes.map((proc) => ({
+        id: proc.id,
+        name: proc.config?.name ?? proc.id,
+        status: proc.status ?? 'unknown',
+        health: healthIndicator(proc.healthStatus),
+        healthColor: healthColor(proc.healthStatus, theme),
+        pid: proc.pid != null ? String(proc.pid) : '—',
+        uptime: proc.status === 'running' ? formatUptime(proc.startedAt) : '—',
+        _process: proc
+    }));
+    // --- Resource table data ---
+    const resourceRows = resources.map((res) => ({
+        id: res.id,
+        name: res.id,
+        status: res.status ?? 'unknown',
+        type: res.type ?? '—'
+    }));
+    // --- Log mode: fetch logs ---
+    const fetchLogs = useCallback(async (processId) => {
+        const client = await resolveClient();
+        if (!client) {
+            setLogContent('PM client unavailable. Open logs again after the monitor connects.');
+            return;
+        }
+        const fetched = await attempt(() => client.getLogs(processId, { lines: LOG_TAIL_LINES }));
+        setLogContent(fetched.ok ? fetched.value : `Error fetching logs: ${failureText(fetched.failure)}`);
+    }, [resolveClient]);
+    // Poll logs in log mode
+    useEffect(() => {
+        if (viewMode !== 'logs' || !selectedProcessId)
+            return;
+        fetchLogs(selectedProcessId);
+        // The TUI host's lifecycle tick (RC07); the disposer ends it with the view.
+        return runtime.lifecycle.interval(() => void fetchLogs(selectedProcessId), 3000);
+    }, [viewMode, selectedProcessId, fetchLogs, runtime]);
+    // --- Actions ---
+    const openLogs = useCallback((processId) => {
+        setSelectedProcessId(processId);
+        setLogContent('Fetching the latest log lines');
+        setViewMode('logs');
+        void fetchLogs(processId);
+    }, [fetchLogs]);
+    const runProcessAction = useCallback(async (verb, process, operation) => {
+        const label = processLabel(process);
+        const client = await resolveClient();
+        if (!client) {
+            setActionFeedback({
+                tone: 'danger',
+                message: `${verb} unavailable for ${label}: PM client unavailable`
+            });
+            return;
+        }
+        setActionFeedback({ tone: 'warning', message: `${verb} running for ${label}...` });
+        const done = await attempt(() => operation(client));
+        setActionFeedback(done.ok
+            ? { tone: 'success', message: `${verb} requested for ${label}` }
+            : { tone: 'danger', message: `${verb} failed for ${label}: ${formatActionError(done.failure)}` });
+    }, [resolveClient]);
+    const resolveStartConfig = useCallback(async (process) => {
+        if (process.config)
+            return process.config;
+        const label = processLabel(process);
+        const client = await resolveClient();
+        if (!client) {
+            setActionFeedback({
+                tone: 'danger',
+                message: `Start unavailable for ${label}: PM client unavailable`
+            });
+            return null;
+        }
+        const fetched = await attempt(() => client.getConfig(process.id));
+        if (!fetched.ok) {
+            setActionFeedback({
+                tone: 'danger',
+                message: `Start unavailable for ${label}: ${formatActionError(fetched.failure)}`
+            });
+            return null;
+        }
+        if (fetched.value)
+            return fetched.value;
+        setActionFeedback({
+            tone: 'danger',
+            message: `Start unavailable for ${label}: missing process config`
+        });
+        return null;
+    }, [resolveClient]);
+    const restartProcess = useCallback(async () => {
+        const proc = highlightedProcess;
+        if (!proc)
+            return;
+        await runProcessAction('Restart', proc, async (client) => {
+            await client.restart(proc.id);
+        });
+    }, [highlightedProcess, runProcessAction]);
+    const stopProcess = useCallback(async () => {
+        const proc = highlightedProcess;
+        if (!proc)
+            return;
+        await runProcessAction('Stop', proc, async (client) => {
+            await client.stop(proc.id);
+        });
+    }, [highlightedProcess, runProcessAction]);
+    const startProcess = useCallback(async () => {
+        const proc = highlightedProcess;
+        if (!proc)
+            return;
+        const verb = startActionVerb(proc);
+        const blockedReason = startBlockedReason(proc);
+        if (blockedReason) {
+            setActionFeedback({
+                tone: 'warning',
+                message: `${verb} unavailable for ${processLabel(proc)}: ${blockedReason}`
+            });
+            return;
+        }
+        const config = await resolveStartConfig(proc);
+        if (!config)
+            return;
+        await runProcessAction(verb, { ...proc, config }, async (client) => {
+            await client.start(config);
+        });
+    }, [highlightedProcess, resolveStartConfig, runProcessAction]);
+    // Quiet daemon-side liveness toggle — see the PMLivenessState doc comment.
+    const setLivenessFull = useCallback(async () => {
+        const client = await resolveClient();
+        if (!client)
+            return;
+        const nextProfile = resolveFullLivenessProfile(activeLiveness);
+        const options = activeLiveness?.env ? { env: activeLiveness.env } : undefined;
+        const mutated = await attempt(() => client.setLivenessProfile(nextProfile, options));
+        if (!mutated.ok) {
+            // Report into the same inline feedback band every other process action
+            // uses; a swallowed failure left the operator staring at stale state.
+            setActionFeedback({
+                tone: 'danger',
+                message: `Liveness change failed: ${formatActionError(mutated.failure)}`
+            });
+            return;
+        }
+        const parsed = LivenessMutationResultSchema.safeParse(mutated.value);
+        const active = parsed.success ? parsed.data.active : undefined;
+        const proxy = parsed.success ? parsed.data.proxy : undefined;
+        setActiveLiveness((prev) => ({
+            ...prev,
+            ...active,
+            profile: active?.profile ?? nextProfile,
+            env: active?.env ?? activeLiveness?.env,
+            proxy: active?.proxy ?? proxy ?? prev?.proxy
+        }));
+    }, [activeLiveness, resolveClient]);
+    // Log mode actions (operate on selectedProcessId)
+    const logProcess = processes.find((p) => p.id === selectedProcessId) ?? null;
+    const restartLogProcess = useCallback(async () => {
+        const proc = logProcess;
+        if (!proc)
+            return;
+        await runProcessAction('Restart', proc, async (client) => {
+            await client.restart(proc.id);
+        });
+    }, [logProcess, runProcessAction]);
+    const stopLogProcess = useCallback(async () => {
+        const proc = logProcess;
+        if (!proc)
+            return;
+        await runProcessAction('Stop', proc, async (client) => {
+            await client.stop(proc.id);
+        });
+    }, [logProcess, runProcessAction]);
+    const startLogProcess = useCallback(async () => {
+        const proc = logProcess;
+        if (!proc)
+            return;
+        const verb = startActionVerb(proc);
+        const blockedReason = startBlockedReason(proc);
+        if (blockedReason) {
+            setActionFeedback({
+                tone: 'warning',
+                message: `${verb} unavailable for ${processLabel(proc)}: ${blockedReason}`
+            });
+            return;
+        }
+        const config = await resolveStartConfig(proc);
+        if (!config)
+            return;
+        await runProcessAction(verb, { ...proc, config }, async (client) => {
+            await client.start(config);
+        });
+    }, [logProcess, resolveStartConfig, runProcessAction]);
+    useEffect(() => {
+        if (processes.length === 0) {
+            if (highlightedProcessId !== null)
+                setHighlightedProcessId(null);
+            return;
+        }
+        if (!highlightedProcessId || !processes.some((process) => process.id === highlightedProcessId)) {
+            setHighlightedProcessId(processes[0]?.id ?? null);
+        }
+    }, [highlightedProcessId, processes]);
+    useKeyboardLayer('global', (key) => {
+        const keyName = key.name?.toLowerCase() ?? '';
+        const isPlain = !key.ctrl && !key.meta && !key.shift && !key.alt;
+        const isEnter = keyName === 'return' || keyName === 'enter';
+        if (!isPlain)
+            return false;
+        if (keyName === 'q') {
+            onExit?.();
+            return true;
+        }
+        if (viewMode === 'list') {
+            if (keyName === '1') {
+                setActiveTab('processes');
+                return true;
+            }
+            if (keyName === '2') {
+                setActiveTab('resources');
+                return true;
+            }
+            if (keyName === 'v' && activeTab === 'processes' && processes.length > 0) {
+                setProcessFilter((prev) => PROCESS_FILTERS[(PROCESS_FILTERS.indexOf(prev) + 1) % PROCESS_FILTERS.length]);
+                return true;
+            }
+            if (keyName === 'f') {
+                void setLivenessFull();
+                return true;
+            }
+        }
+        if (viewMode === 'list' && activeTab === 'processes' && processes.length > 0) {
+            if (keyName === 'down' || keyName === 'arrowdown') {
+                const nextIndex = Math.min(processes.length - 1, Math.max(0, highlightedProcessIndex) + 1);
+                setHighlightedProcessId(processes[nextIndex]?.id ?? null);
+                return true;
+            }
+            if (keyName === 'up' || keyName === 'arrowup') {
+                const nextIndex = Math.max(0, Math.max(0, highlightedProcessIndex) - 1);
+                setHighlightedProcessId(processes[nextIndex]?.id ?? null);
+                return true;
+            }
+            if (isEnter && highlightedProcess) {
+                openLogs(highlightedProcess.id);
+                return true;
+            }
+            if (keyName === 'r' && highlightedProcess?.status === 'running') {
+                void restartProcess();
+                return true;
+            }
+            if (keyName === 'x' && highlightedProcess?.status === 'running') {
+                void stopProcess();
+                return true;
+            }
+            if (keyName === 's' && highlightedProcess && highlightedProcess.status !== 'running') {
+                void startProcess();
+                return true;
+            }
+        }
+        if (viewMode === 'logs') {
+            if (keyName === 'escape') {
+                setViewMode('list');
+                return true;
+            }
+            if (keyName === 'r' && logProcess?.status === 'running') {
+                void restartLogProcess();
+                return true;
+            }
+            if (keyName === 'x' && logProcess?.status === 'running') {
+                void stopLogProcess();
+                return true;
+            }
+            if (keyName === 's' && logProcess && logProcess.status !== 'running') {
+                void startLogProcess();
+                return true;
+            }
+        }
+        return false;
+    }, {
+        description: 'pm-dashboard-shortcuts',
+        deps: [
+            activeTab,
+            highlightedProcess,
+            highlightedProcessIndex,
+            logProcess,
+            onExit,
+            openLogs,
+            processes,
+            processFilter,
+            restartLogProcess,
+            restartProcess,
+            setLivenessFull,
+            startLogProcess,
+            startProcess,
+            stopLogProcess,
+            stopProcess,
+            viewMode
+        ]
+    });
+    // --- Layout ---
+    const screenWidth = dimensions?.width ?? 80;
+    const screenHeight = dimensions?.height ?? 24;
+    const compact = screenWidth <= 90 || screenHeight <= 26;
+    // --- Process selector options for log mode ---
+    const processSelectOptions = processes.map((proc) => ({
+        value: proc.id,
+        name: proc.config?.name ?? proc.id,
+        description: proc.status ?? 'unknown'
+    }));
+    // --- Log lines ---
+    const logLines = logContent === '' ? [] : logContent.split('\n');
+    const health = daemonHealthWord({ hasLoadedMonitorState, hasMonitorError, connected, pmAvailable });
+    const runningCount = allProcesses.filter((p) => p.status === 'running').length;
+    const stoppedCount = allProcesses.filter((p) => p.status === 'stopped').length;
+    const erroredCount = allProcesses.filter((p) => p.status === 'crashed' || p.status === 'fail').length;
+    // The ONE glance line the region table asks for — live counts only, no
+    // route-name/path restatement (the header already names the surface).
+    const glanceText = truncateWords([
+        `${runningCount} running`,
+        `${stoppedCount} stopped`,
+        erroredCount > 0 ? `${erroredCount} errored` : null,
+        pluralize(resources.length, 'resource')
+    ]
+        .filter((part) => Boolean(part))
+        .join(' · '), compact ? 56 : 140);
+    const listHints = [
+        { keys: '1', label: 'processes', priority: 1 },
+        { keys: '2', label: 'resources', priority: 1 },
+        ...(activeTab === 'processes' && processes.length > 0
+            ? [{ keys: 'v', label: 'filter', priority: 2 }]
+            : []),
+        ...(highlightedProcess
+            ? [
+                { keys: 'enter', label: 'logs', priority: 4 },
+                ...(highlightedProcess.status === 'running'
+                    ? [
+                        { keys: 'r', label: 'restart', priority: 3 },
+                        { keys: 'x', label: 'stop', priority: 3 }
+                    ]
+                    : startBlockedReason(highlightedProcess)
+                        ? []
+                        : [{ keys: 's', label: startActionVerb(highlightedProcess).toLowerCase(), priority: 3 }])
+            ]
+            : [])
+    ];
+    const logHints = [
+        { keys: 'escape', label: 'back', priority: 4 },
+        ...(logProcess?.status === 'running'
+            ? [
+                { keys: 'r', label: 'restart', priority: 3 },
+                { keys: 'x', label: 'stop', priority: 3 }
+            ]
+            : logProcess && !startBlockedReason(logProcess)
+                ? [{ keys: 's', label: startActionVerb(logProcess).toLowerCase(), priority: 3 }]
+                : [])
+    ];
+    // Facts + hints ride the one gateway-owned status line: daemon health is
+    // stated HERE (nowhere else — the readiness band's own status dot and the
+    // duplicated refresh-cadence caption are gone); hints only name keys that
+    // work now.
+    useContributeScreenStatus('pm.monitor', {
+        facts: [
+            {
+                slot: 'context',
+                value: viewMode === 'logs' ? `${logLines.length} lines` : `daemon ${health}`,
+                tone: health === 'down' ? 'danger' : health === 'degraded' ? 'warning' : 'muted'
+            }
+        ],
+        hints: viewMode === 'logs' ? logHints : listHints
+    });
+    // Log Mode Render
+    if (viewMode === 'logs') {
+        return (_jsxs(VStack, { grow: true, children: [_jsxs(HStack, { style: {
+                        backgroundColor: dsBase.card,
+                        border: ['bottom'],
+                        borderColor: dsBase.border,
+                        paddingLeft: 1,
+                        paddingRight: 1,
+                        flexShrink: 0
+                    }, children: [_jsxs(OTText, { fg: dsColors.primary.solid, bold: true, children: ["Process logs", ' '] }), _jsx(OTText, { fg: dsBase.foreground, children: logProcess?.config?.name ?? selectedProcessId ?? 'none' }), _jsx(Spacer, {}), _jsxs(OTText, { fg: dsBase.mutedForeground, children: [logLines.length, " lines"] })] }), _jsx(VStack, { style: { flexShrink: 0, maxHeight: 8 }, children: _jsx(DSSearchSelect, { id: "pm-log-process-select", options: processSelectOptions, value: selectedProcessId, onChange: (value) => {
+                            setSelectedProcessId(value);
+                            setLogContent('');
+                        }, placeholder: "Filter processes...", showDescription: false, maxVisibleItems: 4, zone: "content" }) }), _jsx(DSScrollArea, { stickyScroll: true, stickyStart: "bottom", style: { flexGrow: 1, padding: 1 }, children: _jsx(VStack, { style: { flexDirection: 'column' }, children: logLines.length === 0 || (logLines.length === 1 && logLines[0] === '') ? (_jsx(OTText, { fg: dsBase.mutedForeground, children: "No logs available" })) : (logLines.map((line, index) => (_jsx(OTText, { content: line || ' ', fg: logLineColor(line, theme) }, index)))) }) }), actionFeedback ? _jsx(ActionFeedbackLine, { feedback: actionFeedback }) : null] }));
+    }
+    // List Mode Render
+    return (_jsxs(VStack, { style: { flexDirection: 'column', flexGrow: 1 }, children: [_jsx(HStack, { justify: "between", align: "center", paddingLeft: 1, paddingRight: 1, style: { flexShrink: 0, border: ['bottom'], borderColor: dsBase.border }, children: _jsx(HStack, { gap: 1, children: _jsx(OTText, { fg: dsBase.foreground, children: glanceText }) }) }), _jsx(PMRouteContextBand, { routeState: routeState, diagnostics: workspaceDiagnostics, compact: compact }), _jsxs(HStack, { justify: "between", align: "center", paddingLeft: 1, paddingRight: 1, style: { flexShrink: 0, border: ['bottom'], borderColor: dsBase.border }, children: [_jsx(Tabs, { tabs: PM_TABS, activeId: activeTab, onChange: setActiveTab, variant: "underline", noBorder: true, showHints: false, zone: "pm-view-tabs" }), activeTab === 'processes' && processes.length > 0 ? (_jsxs(HStack, { gap: 1, onMouseUp: () => setProcessFilter(cycleProcessFilter), children: [_jsx(DSText, { variant: "muted", children: "Filter" }), _jsx(DSText, { color: dsColors.primary.solid, children: PROCESS_FILTER_LABELS[processFilter] })] })) : null] }), _jsxs(VStack, { style: { flexGrow: 1, flexDirection: 'column', height: 0 }, children: [activeTab === 'processes' && (_jsxs(VStack, { style: { flexDirection: 'column', flexGrow: 1 }, children: [processData?.processesLoading && processes.length === 0 ? (_jsx(VStack, { padding: 2, children: _jsx(DSText, { variant: "muted", children: "Opening the process monitor." }) })) : processData?.processesError ? (_jsx(ErrorDetailsPanel, { title: "Process data failed", message: processData.processesError })) : (_jsx(ProcessTable, { rows: processRows, selectedId: highlightedProcess?.id ?? null, onSelect: (row) => {
+                                    setHighlightedProcessId(row.id);
+                                } })), highlightedProcess && (_jsxs(VStack, { style: {
+                                    flexDirection: 'column',
+                                    border: ['top'],
+                                    borderColor: dsBase.border,
+                                    paddingLeft: 1,
+                                    paddingRight: 1,
+                                    flexShrink: 0
+                                }, children: [_jsxs(HStack, { gap: 2, children: [_jsx(OTText, { fg: healthColor(highlightedProcess.healthStatus, theme), children: healthIndicator(highlightedProcess.healthStatus) }), _jsxs(OTText, { fg: dsBase.mutedForeground, children: ["Restarts: ", highlightedProcess.restartCount ?? 0] })] }), highlightedProcess.lastError && (_jsx(ErrorDetailsPanel, { title: `${highlightedProcess.config?.name ?? highlightedProcess.id} crashed`, message: highlightedProcess.lastError, hint: "Open logs (Enter) for the full trace, then restart the process." }, highlightedProcess.id))] }))] })), activeTab === 'resources' && (_jsx(VStack, { style: { flexDirection: 'column', flexGrow: 1 }, children: processData?.resourcesLoading && resources.length === 0 ? (_jsx(VStack, { padding: 2, children: _jsx(DSText, { variant: "muted", children: "Opening the resource monitor." }) })) : processData?.resourcesError ? (_jsx(ErrorDetailsPanel, { title: "Resource data failed", message: processData.resourcesError })) : (_jsx(ResourceTable, { rows: resourceRows })) }))] }), actionFeedback ? _jsx(ActionFeedbackLine, { feedback: actionFeedback }) : null] }));
+}
+const PM_TABS = [
+    { id: 'processes', label: 'Processes' },
+    { id: 'resources', label: 'Resources' }
+];
+function cycleProcessFilter(prev) {
+    return PROCESS_FILTERS[(PROCESS_FILTERS.indexOf(prev) + 1) % PROCESS_FILTERS.length];
+}
+// Export
+const impl = {
+    component: PMDashboardApp
+};
+export default impl;
+//# sourceMappingURL=pm-dashboard.impl.consumer.js.map