@amplitude/wizard 1.0.0-beta.0

package/dist/src/ui/tui/primitives/ReportViewer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ReportViewer — Scrollable viewer for amplitude-setup-report.md.
+ *
+ * Reads the file from disk and displays it with basic markdown rendering
+ * (headings bold, bullet points preserved). Supports up/down scrolling
+ * via arrow keys or j/k vim keys.
+ */
+interface ReportViewerProps {
+    filePath: string;
+}
+export declare const ReportViewer: ({ filePath }: ReportViewerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/ui/tui/primitives/ReportViewer.js

@@ -0,0 +1,99 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * ReportViewer — Scrollable viewer for amplitude-setup-report.md.
+ *
+ * Reads the file from disk and displays it with basic markdown rendering
+ * (headings bold, bullet points preserved). Supports up/down scrolling
+ * via arrow keys or j/k vim keys.
+ */
+import { Box, Text } from 'ink';
+import { useState, useEffect } from 'react';
+import * as fs from 'fs';
+import { useStdoutDimensions } from '../hooks/useStdoutDimensions.js';
+import { useScreenInput } from '../hooks/useScreenInput.js';
+import { Colors } from '../styles.js';
+/** Rows consumed by ConsoleView border + TitleBar + separator + tab bar chrome */
+const CHROME_ROWS = 10;
+/** Strip markdown syntax for terminal rendering — keep text readable. */
+function renderLine(line) {
+    if (/^#{1,3}\s/.test(line)) {
+        return { text: line.replace(/^#+\s*/, ''), bold: true, dimmed: false };
+    }
+    if (/^---+$/.test(line.trim())) {
+        return { text: '─'.repeat(40), bold: false, dimmed: true };
+    }
+    return { text: line, bold: false, dimmed: false };
+}
+export const ReportViewer = ({ filePath }) => {
+    const [, rows] = useStdoutDimensions();
+    const visibleLines = Math.max(5, rows - CHROME_ROWS);
+    const [lines, setLines] = useState([]);
+    const [offset, setOffset] = useState(0);
+    useEffect(() => {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            setLines(content.split('\n'));
+        }
+        catch {
+            setLines(['(No report found — the agent may still be running)']);
+        }
+        // Watch for the file to appear/update (agent may still be writing)
+        let watcher;
+        let interval;
+        const startWatch = () => {
+            try {
+                watcher = fs.watch(filePath, () => {
+                    try {
+                        const content = fs.readFileSync(filePath, 'utf-8');
+                        setLines(content.split('\n'));
+                    }
+                    catch {
+                        // ignore
+                    }
+                });
+            }
+            catch {
+                // File not yet available — poll
+                interval = setInterval(() => {
+                    try {
+                        fs.accessSync(filePath);
+                        const content = fs.readFileSync(filePath, 'utf-8');
+                        setLines(content.split('\n'));
+                        clearInterval(interval);
+                        interval = undefined;
+                        startWatch();
+                    }
+                    catch {
+                        // still waiting
+                    }
+                }, 1000);
+            }
+        };
+        startWatch();
+        return () => {
+            watcher?.close();
+            if (interval)
+                clearInterval(interval);
+        };
+    }, [filePath]);
+    const maxOffset = Math.max(0, lines.length - visibleLines);
+    useScreenInput((input, key) => {
+        if (key.upArrow || input === 'k') {
+            setOffset((o) => Math.max(0, o - 1));
+        }
+        else if (key.downArrow || input === 'j') {
+            setOffset((o) => Math.min(maxOffset, o + 1));
+        }
+        else if (key.pageUp) {
+            setOffset((o) => Math.max(0, o - visibleLines));
+        }
+        else if (key.pageDown) {
+            setOffset((o) => Math.min(maxOffset, o + visibleLines));
+        }
+    });
+    const visible = lines.slice(offset, offset + visibleLines);
+    return (_jsxs(Box, { flexDirection: "column", height: visibleLines, children: [visible.map((line, i) => {
+                const { text, bold, dimmed } = renderLine(line);
+                return (_jsx(Text, { bold: bold, color: dimmed ? Colors.muted : undefined, wrap: "truncate", children: text }, i));
+            }), lines.length > visibleLines && (_jsxs(Text, { color: Colors.muted, children: [' ', "\u2191\u2193 to scroll \u00B7 ", offset + visibleLines, "/", lines.length, " lines"] }))] }));
+};

package/dist/src/ui/tui/primitives/ScreenErrorBoundary.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ScreenErrorBoundary — catches React render errors in screens
+ * and surfaces them in ConsoleView via store.screenError.
+ *
+ * The error is displayed between the content area and the text input.
+ * Pressing R in ConsoleView increments store.screenErrorRetry, which
+ * causes this boundary to reset and re-render the screen.
+ */
+import { Component, type ReactNode } from 'react';
+import type { WizardStore } from '../store.js';
+interface Props {
+    store: WizardStore;
+    retryToken: number;
+    children: ReactNode;
+}
+interface State {
+    error: Error | null;
+}
+export declare class ScreenErrorBoundary extends Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error): void;
+    componentDidUpdate(prevProps: Props): void;
+    render(): ReactNode;
+}
+export {};

package/dist/src/ui/tui/primitives/ScreenErrorBoundary.js

@@ -0,0 +1,29 @@
+/**
+ * ScreenErrorBoundary — catches React render errors in screens
+ * and surfaces them in ConsoleView via store.screenError.
+ *
+ * The error is displayed between the content area and the text input.
+ * Pressing R in ConsoleView increments store.screenErrorRetry, which
+ * causes this boundary to reset and re-render the screen.
+ */
+import { Component } from 'react';
+export class ScreenErrorBoundary extends Component {
+    state = { error: null };
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    componentDidCatch(error) {
+        this.props.store.setScreenError(error);
+    }
+    componentDidUpdate(prevProps) {
+        if (prevProps.retryToken !== this.props.retryToken && this.state.error) {
+            this.setState({ error: null });
+        }
+    }
+    render() {
+        // When errored, render nothing — ConsoleView shows the banner.
+        if (this.state.error)
+            return null;
+        return this.props.children;
+    }
+}

package/dist/src/ui/tui/primitives/SlashCommandInput.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SlashCommandInput — Text input with slash-command picker.
+ *
+ * When isActive=false (default): renders a dim hint, captures no input.
+ * When isActive=true: captures all input, calls onDeactivate on submit/escape.
+ *
+ * Activation is controlled by the parent (ConsoleView).
+ */
+export interface SlashCommand {
+    cmd: string;
+    desc: string;
+}
+interface SlashCommandInputProps {
+    commands?: SlashCommand[];
+    isActive: boolean;
+    initialValue?: string;
+    onSubmit: (value: string) => void;
+    onDeactivate: () => void;
+}
+export declare const SlashCommandInput: ({ commands, isActive, initialValue, onSubmit, onDeactivate, }: SlashCommandInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/ui/tui/primitives/SlashCommandInput.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * SlashCommandInput — Text input with slash-command picker.
+ *
+ * When isActive=false (default): renders a dim hint, captures no input.
+ * When isActive=true: captures all input, calls onDeactivate on submit/escape.
+ *
+ * Activation is controlled by the parent (ConsoleView).
+ */
+import { Box, Text, useInput } from 'ink';
+import { useState, useEffect } from 'react';
+import { Colors, Icons } from '../styles.js';
+export const SlashCommandInput = ({ commands = [], isActive, initialValue = '', onSubmit, onDeactivate, }) => {
+    const [value, setValue] = useState(initialValue);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [cursorVisible, setCursorVisible] = useState(true);
+    useEffect(() => {
+        if (!isActive)
+            return;
+        setCursorVisible(true);
+        const id = setInterval(() => setCursorVisible((v) => !v), 530);
+        return () => clearInterval(id);
+    }, [isActive]);
+    const isSlashMode = value.startsWith('/');
+    const query = value.slice(1).toLowerCase();
+    const filtered = isSlashMode
+        ? commands
+            .filter((c) => c.cmd.slice(1).startsWith(query) ||
+            c.desc.toLowerCase().includes(query))
+            .sort((a, b) => {
+            const aStarts = a.cmd.slice(1).startsWith(query) ? 0 : 1;
+            const bStarts = b.cmd.slice(1).startsWith(query) ? 0 : 1;
+            return aStarts - bStarts;
+        })
+        : [];
+    const clampedIndex = Math.min(selectedIndex, Math.max(0, filtered.length - 1));
+    useInput((char, key) => {
+        if (key.upArrow && isSlashMode) {
+            setSelectedIndex((i) => Math.max(0, i - 1));
+            return;
+        }
+        if (key.downArrow && isSlashMode) {
+            setSelectedIndex((i) => Math.min(filtered.length - 1, i + 1));
+            return;
+        }
+        if (key.return) {
+            if (isSlashMode && filtered.length > 0) {
+                onSubmit(filtered[clampedIndex].cmd);
+            }
+            else if (value.trim()) {
+                onSubmit(value.trim());
+            }
+            setValue('');
+            setSelectedIndex(0);
+            onDeactivate();
+            return;
+        }
+        if (key.escape) {
+            setValue('');
+            setSelectedIndex(0);
+            onDeactivate();
+            return;
+        }
+        if (key.backspace || key.delete) {
+            const next = value.slice(0, -1);
+            setValue(next);
+            setSelectedIndex(0);
+            if (next === '')
+                onDeactivate();
+            return;
+        }
+        if (key.ctrl || key.meta || key.tab)
+            return;
+        if (char) {
+            setValue((v) => v + char);
+            setSelectedIndex(0);
+        }
+    }, { isActive });
+    if (!isActive) {
+        return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: Colors.muted, children: '>' }), _jsx(Text, { color: Colors.muted, inverse: false, children: ' ' })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: Colors.muted, children: '>' }), _jsxs(Text, { children: [value, cursorVisible ? _jsx(Text, { inverse: true, children: " " }) : _jsx(Text, { children: " " })] })] }), isSlashMode && filtered.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: filtered.map((c, i) => (_jsxs(Box, { gap: 2, children: [_jsx(Text, { color: i === clampedIndex ? Colors.primary : undefined, bold: i === clampedIndex, children: i === clampedIndex
+                                ? Icons.triangleSmallRight + ' ' + c.cmd
+                                : '  ' + c.cmd }), _jsx(Text, { color: i !== clampedIndex ? Colors.muted : undefined, children: c.desc })] }, c.cmd))) }))] }));
+};

package/dist/src/ui/tui/primitives/SnakeGame.d.ts

@@ -0,0 +1 @@
+export { SnakeGame } from '@pavus/snake-game';

package/dist/src/ui/tui/primitives/SnakeGame.js

@@ -0,0 +1 @@
+export { SnakeGame } from '@pavus/snake-game';

package/dist/src/ui/tui/primitives/SplitView.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SplitView — Two-pane horizontal layout: 50/50.
+ */
+import type { ReactNode } from 'react';
+interface SplitViewProps {
+    left: ReactNode;
+    right: ReactNode;
+    gap?: number;
+}
+export declare const SplitView: ({ left, right, gap }: SplitViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/ui/tui/primitives/SplitView.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * SplitView — Two-pane horizontal layout: 50/50.
+ */
+import { Box } from 'ink';
+export const SplitView = ({ left, right, gap = 2 }) => {
+    return (_jsxs(Box, { flexDirection: "row", flexGrow: 1, gap: gap, children: [_jsx(Box, { width: "50%", flexDirection: "column", children: left }), _jsx(Box, { width: "50%", flexDirection: "column", children: right })] }));
+};

package/dist/src/ui/tui/primitives/TabContainer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * TabContainer — Self-contained tabbed interface.
+ * Absorbs BottomTabBar + StatusPanel functionality.
+ */
+import { type ReactNode } from 'react';
+export interface TabDefinition {
+    id: string;
+    label: string;
+    component: ReactNode;
+}
+interface TabContainerProps {
+    tabs: TabDefinition[];
+    statusMessage?: string;
+    requestedTab?: string | null;
+    onTabConsumed?: () => void;
+}
+export declare const TabContainer: ({ tabs, statusMessage, requestedTab, onTabConsumed, }: TabContainerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/ui/tui/primitives/TabContainer.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * TabContainer — Self-contained tabbed interface.
+ * Absorbs BottomTabBar + StatusPanel functionality.
+ */
+import { Box, Text } from 'ink';
+import { useScreenInput } from '../hooks/useScreenInput.js';
+import { useState, useEffect } from 'react';
+import { Colors, Icons } from '../styles.js';
+export const TabContainer = ({ tabs, statusMessage, requestedTab, onTabConsumed, }) => {
+    const [activeTab, setActiveTab] = useState(0);
+    useEffect(() => {
+        if (!requestedTab)
+            return;
+        const idx = tabs.findIndex((t) => t.id === requestedTab);
+        if (idx !== -1)
+            setActiveTab(idx);
+        onTabConsumed?.();
+    }, [requestedTab]);
+    useScreenInput((_input, key) => {
+        if (key.leftArrow) {
+            setActiveTab((prev) => Math.max(0, prev - 1));
+        }
+        if (key.rightArrow) {
+            setActiveTab((prev) => Math.min(tabs.length - 1, prev + 1));
+        }
+    });
+    const current = tabs[activeTab];
+    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Box, { flexDirection: "column", flexGrow: 1, children: current?.component }), statusMessage && (_jsx(Box, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: Colors.muted, paddingX: 1, overflow: "hidden", children: _jsxs(Text, { color: Colors.muted, children: [Icons.diamondOpen, " ", statusMessage] }) })), _jsx(Box, { height: 1 }), _jsxs(Box, { gap: 1, paddingX: 1, justifyContent: "space-between", children: [_jsx(Box, { gap: 1, children: tabs.map((tab, i) => (_jsx(Text, { inverse: i === activeTab, color: i === activeTab ? Colors.accent : Colors.muted, bold: i === activeTab, children: ` ${tab.label} ` }, tab.id))) }), _jsx(Text, { color: Colors.muted, children: "\u2190 \u2192 to browse tabs while the wizard runs" })] })] }));
+};

package/dist/src/ui/tui/primitives/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Barrel export for all TUI layout primitives.
+ */
+export { CardLayout } from './CardLayout.js';
+export { SplitView } from './SplitView.js';
+export { LoadingBox } from './LoadingBox.js';
+export { ProgressList } from './ProgressList.js';
+export type { ProgressItem } from './ProgressList.js';
+export { PromptLabel } from './PromptLabel.js';
+export { PickerMenu } from './PickerMenu.js';
+export { ConfirmationInput } from './ConfirmationInput.js';
+export { LogViewer } from './LogViewer.js';
+export { ReportViewer } from './ReportViewer.js';
+export { EventPlanViewer } from './EventPlanViewer.js';
+export { ScreenErrorBoundary } from './ScreenErrorBoundary.js';
+export { TabContainer } from './TabContainer.js';
+export type { TabDefinition } from './TabContainer.js';
+export { KagiSmallWebViewer } from './KagiSmallWebViewer.js';
+export { SnakeGame } from './SnakeGame.js';
+export { DissolveTransition } from './DissolveTransition.js';
+export type { WipeDirection } from './DissolveTransition.js';
+export { SlashCommandInput } from './SlashCommandInput.js';
+export type { SlashCommand } from './SlashCommandInput.js';

package/dist/src/ui/tui/primitives/index.js

@@ -0,0 +1,19 @@
+/**
+ * Barrel export for all TUI layout primitives.
+ */
+export { CardLayout } from './CardLayout.js';
+export { SplitView } from './SplitView.js';
+export { LoadingBox } from './LoadingBox.js';
+export { ProgressList } from './ProgressList.js';
+export { PromptLabel } from './PromptLabel.js';
+export { PickerMenu } from './PickerMenu.js';
+export { ConfirmationInput } from './ConfirmationInput.js';
+export { LogViewer } from './LogViewer.js';
+export { ReportViewer } from './ReportViewer.js';
+export { EventPlanViewer } from './EventPlanViewer.js';
+export { ScreenErrorBoundary } from './ScreenErrorBoundary.js';
+export { TabContainer } from './TabContainer.js';
+export { KagiSmallWebViewer } from './KagiSmallWebViewer.js';
+export { SnakeGame } from './SnakeGame.js';
+export { DissolveTransition } from './DissolveTransition.js';
+export { SlashCommandInput } from './SlashCommandInput.js';

package/dist/src/ui/tui/router.d.ts

@@ -0,0 +1,61 @@
+/**
+ * WizardRouter — declarative flow pipelines + overlay stack.
+ *
+ * Two layers:
+ *   Flow cursor    — linear pipeline of screens, advanced with next()
+ *   Overlay stack  — interrupts (outage, auth-expired, etc.) that push/pop
+ *
+ * The visible screen is: top of overlay stack if non-empty, otherwise the flow cursor.
+ *
+ * Adding a flow screen = append to a pipeline array.
+ * Adding an overlay = call pushOverlay() from anywhere.
+ * No switch statements, no hardcoded transitions in business logic.
+ */
+import type { WizardSession } from '../../lib/wizard-session.js';
+import { Screen, Flow, type FlowEntry } from './flows.js';
+export { Screen, Flow };
+export type { FlowEntry };
+/** Screens that interrupt flows as overlays */
+export declare enum Overlay {
+    Outage = "outage",
+    SettingsOverride = "settings-override",
+    Snake = "snake",
+    Mcp = "mcp-overlay",
+    Slack = "slack-overlay",
+    Logout = "logout-overlay",
+    Login = "login-overlay"
+}
+/** Union of all screen names */
+export type ScreenName = Screen | Overlay;
+export declare class WizardRouter {
+    private flow;
+    private flowName;
+    private overlays;
+    constructor(flowName?: Flow);
+    /**
+     * Resolve which screen should be active based on session state.
+     * Walks the flow pipeline, skipping hidden entries and completed entries,
+     * returns the first incomplete screen.
+     */
+    resolve(session: WizardSession): ScreenName;
+    /** The screen that should be rendered right now. */
+    get activeScreen(): ScreenName;
+    /** The name of the active flow. */
+    get activeFlow(): Flow;
+    /** Whether an overlay is currently active. */
+    get hasOverlay(): boolean;
+    /**
+     * Push an overlay that interrupts the current flow.
+     * The flow resumes when the overlay is dismissed via popOverlay().
+     */
+    pushOverlay(overlay: Overlay): void;
+    /**
+     * Dismiss the topmost overlay. The flow screen underneath resumes.
+     */
+    popOverlay(): void;
+    /**
+     * Direction hint for screen transitions.
+     */
+    private _lastDirection;
+    get lastNavDirection(): 'push' | 'pop' | null;
+}

package/dist/src/ui/tui/router.js

@@ -0,0 +1,104 @@
+/**
+ * WizardRouter — declarative flow pipelines + overlay stack.
+ *
+ * Two layers:
+ *   Flow cursor    — linear pipeline of screens, advanced with next()
+ *   Overlay stack  — interrupts (outage, auth-expired, etc.) that push/pop
+ *
+ * The visible screen is: top of overlay stack if non-empty, otherwise the flow cursor.
+ *
+ * Adding a flow screen = append to a pipeline array.
+ * Adding an overlay = call pushOverlay() from anywhere.
+ * No switch statements, no hardcoded transitions in business logic.
+ */
+import { OutroKind } from '../../lib/wizard-session.js';
+import { FLOWS, Screen, Flow } from './flows.js';
+// Re-export so existing imports from './router.js' keep working
+export { Screen, Flow };
+// ── Screen name taxonomy ──────────────────────────────────────────────
+/** Screens that interrupt flows as overlays */
+export var Overlay;
+(function (Overlay) {
+    Overlay["Outage"] = "outage";
+    Overlay["SettingsOverride"] = "settings-override";
+    Overlay["Snake"] = "snake";
+    Overlay["Mcp"] = "mcp-overlay";
+    Overlay["Slack"] = "slack-overlay";
+    Overlay["Logout"] = "logout-overlay";
+    Overlay["Login"] = "login-overlay";
+})(Overlay || (Overlay = {}));
+// ── Router ────────────────────────────────────────────────────────────
+export class WizardRouter {
+    flow;
+    flowName;
+    overlays = [];
+    constructor(flowName = Flow.Wizard) {
+        this.flowName = flowName;
+        this.flow = FLOWS[flowName];
+    }
+    /**
+     * Resolve which screen should be active based on session state.
+     * Walks the flow pipeline, skipping hidden entries and completed entries,
+     * returns the first incomplete screen.
+     */
+    resolve(session) {
+        if (this.overlays.length > 0) {
+            return this.overlays[this.overlays.length - 1];
+        }
+        // If the user cancelled before the run completed, jump directly to Outro.
+        // Success/Error are handled by the normal flow (MCP + Slack still need to show).
+        if (session.outroData?.kind === OutroKind.Cancel) {
+            return Screen.Outro;
+        }
+        for (const entry of this.flow) {
+            if (entry.show && !entry.show(session))
+                continue;
+            if (entry.isComplete && entry.isComplete(session))
+                continue;
+            return entry.screen;
+        }
+        // All entries complete — show the last screen (outro)
+        return this.flow[this.flow.length - 1].screen;
+    }
+    /** The screen that should be rendered right now. */
+    get activeScreen() {
+        // Overlays take priority — resolve() handles this too,
+        // but activeScreen is called before session is available in some paths
+        if (this.overlays.length > 0) {
+            return this.overlays[this.overlays.length - 1];
+        }
+        return this.flow[0].screen;
+    }
+    /** The name of the active flow. */
+    get activeFlow() {
+        return this.flowName;
+    }
+    /** Whether an overlay is currently active. */
+    get hasOverlay() {
+        return this.overlays.length > 0;
+    }
+    /**
+     * Push an overlay that interrupts the current flow.
+     * The flow resumes when the overlay is dismissed via popOverlay().
+     */
+    pushOverlay(overlay) {
+        this.overlays.push(overlay);
+    }
+    /**
+     * Dismiss the topmost overlay. The flow screen underneath resumes.
+     */
+    popOverlay() {
+        this.overlays.pop();
+    }
+    /**
+     * Direction hint for screen transitions.
+     */
+    _lastDirection = null;
+    get lastNavDirection() {
+        return this._lastDirection;
+    }
+    /** @internal — called by store wrapper to track direction */
+    _setDirection(dir) {
+        this._lastDirection = dir;
+    }
+}

package/dist/src/ui/tui/screen-registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Screen registry — maps screen names to React components.
+ *
+ * Adding a new screen:
+ *   1. Create the component in screens/
+ *   2. Add an entry here
+ *   3. Add the screen name to the router flow (router.ts)
+ *
+ * App.tsx never needs to change.
+ */
+import type { ReactNode } from 'react';
+import type { WizardStore } from './store.js';
+import { type ScreenName } from './router.js';
+import type { McpInstaller } from './services/mcp-installer.js';
+export interface ScreenServices {
+    mcpInstaller: McpInstaller;
+}
+export declare function createServices(localMcp?: boolean): ScreenServices;
+export declare function createScreens(store: WizardStore, services: ScreenServices): Record<ScreenName, ReactNode>;

package/dist/src/ui/tui/screen-registry.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Screen, Overlay } from './router.js';
+import { OutageScreen } from './screens/OutageScreen.js';
+import { SettingsOverrideScreen } from './screens/SettingsOverrideScreen.js';
+import { IntroScreen } from './screens/IntroScreen.js';
+import { SetupScreen } from './screens/SetupScreen.js';
+import { AuthScreen } from './screens/AuthScreen.js';
+import { RegionSelectScreen } from './screens/RegionSelectScreen.js';
+import { DataSetupScreen } from './screens/DataSetupScreen.js';
+import { ActivationOptionsScreen } from './screens/ActivationOptionsScreen.js';
+import { RunScreen } from './screens/RunScreen.js';
+import { McpScreen } from './screens/McpScreen.js';
+import { DataIngestionCheckScreen } from './screens/DataIngestionCheckScreen.js';
+import { ChecklistScreen } from './screens/ChecklistScreen.js';
+import { SlackScreen } from './screens/SlackScreen.js';
+import { LogoutScreen } from './screens/LogoutScreen.js';
+import { LoginScreen } from './screens/LoginScreen.js';
+import { OutroScreen } from './screens/OutroScreen.js';
+import { createMcpInstaller } from './services/mcp-installer.js';
+import { SnakeGame } from './primitives/SnakeGame.js';
+export function createServices(localMcp = false) {
+    return {
+        mcpInstaller: createMcpInstaller(localMcp),
+    };
+}
+export function createScreens(store, services) {
+    return {
+        // Overlays
+        [Overlay.Outage]: _jsx(OutageScreen, { store: store }),
+        [Overlay.SettingsOverride]: _jsx(SettingsOverrideScreen, { store: store }),
+        [Overlay.Snake]: _jsx(SnakeGame, { onExit: () => store.hideSnakeOverlay() }),
+        [Overlay.Mcp]: (_jsx(McpScreen, { store: store, installer: services.mcpInstaller, onComplete: () => store.hideMcpOverlay() })),
+        [Overlay.Slack]: (_jsx(SlackScreen, { store: store, onComplete: () => store.hideSlackOverlay() })),
+        [Overlay.Logout]: (_jsx(LogoutScreen, { onComplete: () => store.hideLogoutOverlay(), installDir: store.session.installDir })),
+        [Overlay.Login]: (_jsx(LoginScreen, { store: store, onComplete: () => store.hideLoginOverlay() })),
+        // Wizard flow
+        [Screen.Intro]: _jsx(IntroScreen, { store: store }),
+        [Screen.Setup]: _jsx(SetupScreen, { store: store }),
+        [Screen.Auth]: _jsx(AuthScreen, { store: store }),
+        [Screen.RegionSelect]: _jsx(RegionSelectScreen, { store: store }),
+        [Screen.DataSetup]: _jsx(DataSetupScreen, { store: store }),
+        [Screen.ActivationOptions]: _jsx(ActivationOptionsScreen, { store: store }),
+        [Screen.Options]: null,
+        [Screen.Run]: _jsx(RunScreen, { store: store }),
+        [Screen.Mcp]: _jsx(McpScreen, { store: store, installer: services.mcpInstaller }),
+        [Screen.DataIngestionCheck]: _jsx(DataIngestionCheckScreen, { store: store }),
+        [Screen.Checklist]: _jsx(ChecklistScreen, { store: store }),
+        [Screen.Outro]: _jsx(OutroScreen, { store: store }),
+        // Standalone MCP flows
+        [Screen.McpAdd]: (_jsx(McpScreen, { store: store, installer: services.mcpInstaller, standalone: true })),
+        [Screen.McpRemove]: (_jsx(McpScreen, { store: store, installer: services.mcpInstaller, mode: "remove", standalone: true })),
+        // Slack integration (in-wizard step and standalone flow)
+        [Screen.Slack]: _jsx(SlackScreen, { store: store }),
+        [Screen.SlackSetup]: _jsx(SlackScreen, { store: store, standalone: true }),
+    };
+}

package/dist/src/ui/tui/screens/ActivationOptionsScreen.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ActivationOptionsScreen — "What would you like to do?" prompt.
+ *
+ * Shown when the user has the SDK installed but hasn't fully activated yet
+ * (1–49 events). Offers next-step options without forcing a full re-run.
+ */
+import type { WizardStore } from '../store.js';
+interface ActivationOptionsScreenProps {
+    store: WizardStore;
+}
+export declare const ActivationOptionsScreen: ({ store, }: ActivationOptionsScreenProps) => import("react/jsx-runtime").JSX.Element;
+export {};