@cortexkit/opencode-magic-context 0.42.5 → 0.43.0

package/src/v2/tui/index.ts

@@ -0,0 +1,526 @@
+import { jsx } from "@opentui/solid/jsx-runtime";
+import { COMPACTION_ENABLED_PATH } from "../../config/agent-disable";
+import { flushLogger, log } from "../../shared/logger";
+import type { SidebarSnapshot, StatusDetail } from "../../shared/rpc-types";
+import { compactionOffSidebarRows, nativeCompactionContextLabel } from "../../tui/compaction-off";
+import {
+    type CommandRpcResult,
+    closeRpc,
+    getCompartmentCount,
+    initRpcClient,
+    loadSidebarSnapshot,
+    loadStatusDetail,
+    requestDream,
+    requestEmbed,
+    requestFlush,
+    requestRecomp,
+    requestWrapup,
+} from "../../tui/data/context-db";
+import {
+    type SocketNotification,
+    startNotificationSocket,
+    stopNotificationSocket,
+} from "../../tui/data/notification-socket";
+import { eventSessionID } from "./events";
+import { mountV1Sidebar, type V1SidebarMount } from "./sidebar-mount";
+import { mountV1StatusDialog, type V1StatusDialogMount } from "./status-dialog-mount";
+import type { V2KeymapLayer, V2SidebarState, V2TuiContext } from "./types";
+
+const SIDEBAR_REFRESH_MS = 1_000;
+const inflight = new Set<string>();
+const refreshedAt = new Map<string, number>();
+
+function compactTokens(value: number): string {
+    if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
+    if (value >= 1_000) return `${Math.round(value / 1_000)}K`;
+    return String(value);
+}
+
+/**
+ * Plain-text projection of the sidebar snapshot, used only when the real v1
+ * component cannot be loaded because the host registers no OpenTUI runtime
+ * modules (`opentui:runtime-module:*`). That arm is reachable on a host that
+ * boots the TUI without OpenTUI's runtime-plugin support installed — for
+ * example a future or cut-down OpenCode 2 TUI, or any embedding of this setup
+ * outside the packaged host. GA 2.0.5 and 2.0.11 both register the modules, so
+ * on those hosts the v1 component is what paints.
+ *
+ * Exported for test access; mirrors the v1 sidebar's compaction-off rows.
+ */
+export function sidebarText(snapshot: SidebarSnapshot | undefined): string {
+    if (!snapshot) return "Magic Context · loading…";
+    if (snapshot.compaction_enabled === false) {
+        return [
+            "Magic Context",
+            nativeCompactionContextLabel(snapshot),
+            ...compactionOffSidebarRows(snapshot).map((row) => `${row.label} ${row.value}`),
+            ...(snapshot.readySmartNoteCount > 0
+                ? [`Smart Notes ${snapshot.readySmartNoteCount} ready`]
+                : []),
+            ...(snapshot.lastTransformError ? [`Warning: ${snapshot.lastTransformError}`] : []),
+        ].join("\n");
+    }
+    const pressure =
+        snapshot.contextLimit > 0
+            ? `${snapshot.usagePercentage.toFixed(1)}% · ${compactTokens(snapshot.inputTokens)}/${compactTokens(snapshot.contextLimit)}`
+            : `${compactTokens(snapshot.inputTokens)} tokens`;
+    const historian = snapshot.historianRunning ? "running" : "idle";
+    return [
+        "Magic Context",
+        `Context ${pressure}`,
+        `Historian ${historian} · C:${snapshot.compartmentCount}`,
+        `Memories ${snapshot.memoryBlockCount}/${snapshot.memoryCount} · Q:${snapshot.pendingOpsCount}`,
+        ...(snapshot.lastTransformError ? [`Warning: ${snapshot.lastTransformError}`] : []),
+    ].join("\n");
+}
+
+/**
+ * Plain-text projection of the status snapshot, used only when the real v1
+ * dialog component cannot be mounted — a host that publishes no component
+ * dialog surface, or one that registers no OpenTUI runtime modules
+ * (`opentui:runtime-module:*`). GA 2.0.5 and 2.0.11 do both, so on those hosts
+ * the v1 dialog is what paints.
+ *
+ * Exported for test access.
+ */
+export function statusText(detail: StatusDetail): string {
+    const context =
+        detail.contextLimit > 0
+            ? `${detail.usagePercentage.toFixed(1)}% (${compactTokens(detail.inputTokens)}/${compactTokens(detail.contextLimit)} tokens)`
+            : `${compactTokens(detail.inputTokens)} tokens`;
+    return [
+        ...(detail.compaction_enabled === false
+            ? [
+                  `Compaction: disabled (${COMPACTION_ENABLED_PATH}: false) — native compaction owns the context window.`,
+              ]
+            : []),
+        `Context: ${context}`,
+        `Historian: ${detail.historianRunning ? "running" : "idle"}`,
+        `Compartments: ${detail.compartmentCount}`,
+        `Memories: ${detail.memoryBlockCount} injected / ${detail.memoryCount} stored`,
+        `Pending reductions: ${detail.pendingOpsCount}`,
+        `Harness: opencode2`,
+        ...(detail.configGeneration === undefined
+            ? []
+            : [
+                  `Config generation: ${detail.configGeneration} (adopted ${detail.configAdoptedAt ? new Date(detail.configAdoptedAt).toLocaleString() : "unknown"})`,
+              ]),
+        ...(detail.configReloadFailure
+            ? [
+                  `Config reload failed ${detail.configReloadFailure.path}: ${detail.configReloadFailure.message}`,
+              ]
+            : []),
+        ...(detail.lastTransformError ? [`Warning: ${detail.lastTransformError}`] : []),
+    ].join("\n");
+}
+
+function currentSessionID(context: V2TuiContext): string | null {
+    const route = context.ui.router.current();
+    return route.type === "session" && route.sessionID ? route.sessionID : null;
+}
+
+type JsxFactory = (type: string, props: Record<string, unknown>) => unknown;
+
+export async function setupWithJsx(context: V2TuiContext, jsx: JsxFactory): Promise<() => void> {
+    const directory = context.location?.directory ?? context.data.location.default().directory;
+    initRpcClient(directory);
+    const [sidebar, updateSidebar] = context.storage.memory<V2SidebarState>(
+        "magic-context.sidebar.v2",
+        { initial: { snapshots: {} } },
+    );
+
+    const refresh = async (sessionID: string, force = false): Promise<void> => {
+        if (!sessionID || inflight.has(sessionID)) return;
+        const now = Date.now();
+        if (!force && now - (refreshedAt.get(sessionID) ?? 0) < SIDEBAR_REFRESH_MS) return;
+        refreshedAt.set(sessionID, now);
+        inflight.add(sessionID);
+        try {
+            const snapshot = await loadSidebarSnapshot(sessionID, directory);
+            updateSidebar((draft) => {
+                draft.snapshots[sessionID] = snapshot;
+            });
+            context.renderer.requestRender();
+        } finally {
+            inflight.delete(sessionID);
+        }
+    };
+
+    const showStatus = async (target = currentSessionID(context)) => {
+        if (!target) {
+            context.ui.toast.show({ message: "No active session", variant: "warning" });
+            return false;
+        }
+        const result = await loadStatusDetail(target, directory);
+        if (currentSessionID(context) !== target) return false;
+        if (!result.ok) {
+            context.ui.toast.show({
+                message: "Magic Context status is unavailable",
+                variant: "warning",
+            });
+            return false;
+        }
+        const mounted = statusDialog;
+        if (mounted) {
+            try {
+                mounted.show(result.detail);
+                return true;
+            } catch (error) {
+                // A component that throws while opening would leave the host
+                // with a dead dialog surface. Degrade to the text dialog for the
+                // rest of this TUI session and say so once.
+                statusDialog = null;
+                console.warn("[magic-context] v2 status dialog failed; using text", error);
+            }
+        }
+        await context.ui.dialog.alert({
+            title: "Magic Context status",
+            message: statusText(result.detail),
+        });
+        return true;
+    };
+
+    const showRecomp = async (target = currentSessionID(context)) => {
+        if (!target) {
+            context.ui.toast.show({ message: "No active session", variant: "warning" });
+            return false;
+        }
+        const count = await getCompartmentCount(target, directory);
+        if (currentSessionID(context) !== target) return false;
+        if (!count.ok) {
+            context.ui.toast.show({ message: "Unable to load recomp details", variant: "error" });
+            return false;
+        }
+        const confirmed = await context.ui.dialog.confirm({
+            title: "Recomp confirmation",
+            message: [
+                count.count === 0
+                    ? "This session has no compartments yet; recomp will build them from raw history."
+                    : `This session has ${count.count} compartments.`,
+                "Recomp rebuilds compressed history and can consume significant tokens.",
+            ].join("\n\n"),
+            label: { confirm: "Run recomp", cancel: "Cancel" },
+        });
+        if (!confirmed) return true;
+        const requested = await requestRecomp(target);
+        context.ui.toast.show({
+            message: requested
+                ? "Recomp requested; historian will start shortly"
+                : "Recomp request failed",
+            variant: requested ? "info" : "error",
+        });
+        if (requested) void refresh(target, true);
+        return requested;
+    };
+
+    const showDream = async (task?: string) => {
+        const target = currentSessionID(context);
+        if (!target) {
+            context.ui.toast.show({ message: "No active session", variant: "warning" });
+            return false;
+        }
+        const started = await requestDream(target, task);
+        context.ui.toast.show({
+            message: started
+                ? "Dream run started; the summary appears when it finishes"
+                : "Dream request failed",
+            variant: started ? "info" : "error",
+        });
+        return started;
+    };
+
+    // One sidebar: the OpenCode 1 component, mounted on the v2 slot through the
+    // host's own OpenTUI runtime. `mountV1Sidebar` returns null only when the
+    // host registers no runtime modules to load it through, which is the single
+    // case the plain-text projection covers.
+    let mountedSidebar: V1SidebarMount | null = await mountV1Sidebar(context, directory);
+    // One status view: the OpenCode 1 dialog component, mounted on the v2 dialog
+    // surface through the host's own OpenTUI runtime. `mountV1StatusDialog`
+    // returns null only for a host that cannot render a component dialog, which
+    // is the single case the plain-text projection covers.
+    let statusDialog: V1StatusDialogMount | null = await mountV1StatusDialog(context);
+    const unregisterSlot = context.ui.slot({
+        append: "sidebar.content",
+        render: (input) => {
+            const mounted = mountedSidebar;
+            if (mounted) {
+                try {
+                    return mounted.render(input);
+                } catch (error) {
+                    // A component that throws mid-paint would take the host's
+                    // sidebar down with it. Degrade to the text projection for
+                    // the rest of this TUI session and say so once.
+                    mountedSidebar = null;
+                    mounted.dispose();
+                    console.warn("[magic-context] v2 sidebar component failed; using text", error);
+                }
+            }
+            void refresh(input.sessionID);
+            return jsx("text", { children: sidebarText(sidebar.snapshots[input.sessionID]) });
+        },
+    });
+
+    // Every /ctx-* command this host can reach goes through the keymap layer:
+    // OpenCode 2 has no `command.execute.before` hook, so the server-side command
+    // handler the OpenCode 1 plugin uses never runs here. Each `run` calls the
+    // RPC handler that does the same server-side work and reports back through a
+    // dialog or toast, because this host has no ignored-message chat carrier.
+    const runCommandRpc = async (
+        title: string,
+        call: (sessionID: string) => Promise<CommandRpcResult>,
+        pending?: string,
+    ): Promise<boolean> => {
+        const target = currentSessionID(context);
+        if (!target) {
+            context.ui.toast.show({ message: "No active session", variant: "warning" });
+            return false;
+        }
+        const result = await call(target);
+        if (!result.ok) {
+            context.ui.toast.show({
+                message: result.error ?? `${title} request failed`,
+                variant: "error",
+            });
+            return false;
+        }
+        // A started background run has no text yet; its outcome arrives later as a
+        // show-result-dialog notification.
+        if (result.started) {
+            context.ui.toast.show({ message: pending ?? `${title} started`, variant: "info" });
+            return true;
+        }
+        if (currentSessionID(context) !== target) return false;
+        await context.ui.dialog.alert({ title, message: result.message ?? "" });
+        return true;
+    };
+
+    // OpenCode 2 runs plugin setup() outside the TUI component tree, where
+    // context.keymap.layer() throws "Keymap.Provider is missing" (the provider is
+    // a Solid context). Try the direct call first (hosts that do run setup
+    // in-tree), then fall back to the app slot: its render executes inside the
+    // component tree, the same place the host's own built-in plugins register
+    // their layers.
+    const buildKeymapLayer = (): V2KeymapLayer => ({
+        mode: "global",
+        commands: [
+            {
+                id: "magic-context.status",
+                title: "Magic Context: Status",
+                group: "Magic Context",
+                palette: true,
+                slash: { name: "ctx-status" },
+                run: async () => {
+                    await showStatus();
+                },
+            },
+            {
+                id: "magic-context.recomp",
+                title: "Magic Context: Recomp",
+                group: "Magic Context",
+                palette: true,
+                slash: { name: "ctx-recomp" },
+                run: async () => {
+                    await showRecomp();
+                },
+            },
+            {
+                id: "magic-context.dream",
+                title: "Magic Context: Dream",
+                group: "Magic Context",
+                palette: true,
+                slash: { name: "ctx-dream", arguments: true },
+                run: async (input) => {
+                    await showDream(input?.trim() || undefined);
+                },
+            },
+            {
+                id: "magic-context.flush",
+                title: "Magic Context: Flush",
+                group: "Magic Context",
+                palette: true,
+                slash: { name: "ctx-flush" },
+                run: async () => {
+                    const flushed = await runCommandRpc("Flush", requestFlush);
+                    if (flushed) void refresh(currentSessionID(context) ?? "", true);
+                },
+            },
+            {
+                id: "magic-context.embed",
+                title: "Magic Context: Embed",
+                group: "Magic Context",
+                palette: true,
+                slash: { name: "ctx-embed", arguments: true },
+                run: async (input) => {
+                    const argument = input?.trim().toLowerCase() ?? "";
+                    if (argument !== "" && argument !== "start" && argument !== "pause") {
+                        context.ui.toast.show({
+                            message:
+                                "Usage: /ctx-embed (status), /ctx-embed start, or /ctx-embed pause",
+                            variant: "warning",
+                        });
+                        return;
+                    }
+                    const action = argument === "" ? "status" : argument;
+                    await runCommandRpc(
+                        "Embed",
+                        (sessionID) => requestEmbed(sessionID, action, directory),
+                        "Embedding started; the summary appears when it finishes",
+                    );
+                },
+            },
+            {
+                id: "magic-context.wrapup",
+                title: "Magic Context: Wrapup",
+                group: "Magic Context",
+                palette: true,
+                slash: { name: "ctx-wrapup", arguments: true },
+                run: async (input) => {
+                    const argument = input?.trim() ?? "";
+                    if (argument !== "" && !/^\d+$/.test(argument)) {
+                        context.ui.toast.show({
+                            message:
+                                "Usage: /ctx-wrapup [messages_to_keep] where messages_to_keep is a positive integer",
+                            variant: "warning",
+                        });
+                        return;
+                    }
+                    const messagesToKeep = argument === "" ? 20 : Number.parseInt(argument, 10);
+                    if (messagesToKeep <= 0) {
+                        context.ui.toast.show({
+                            message: "messages_to_keep must be a positive integer",
+                            variant: "warning",
+                        });
+                        return;
+                    }
+                    await runCommandRpc(
+                        "Wrapup",
+                        (sessionID) => requestWrapup(sessionID, messagesToKeep),
+                        "Wrapup started; the summary appears when it finishes",
+                    );
+                },
+            },
+        ],
+    });
+    let keymapLayerRegistered = false;
+    let keymapGapLogged = false;
+    const registerKeymapLayer = (): boolean => {
+        if (keymapLayerRegistered) return true;
+        try {
+            context.keymap.layer(buildKeymapLayer);
+            keymapLayerRegistered = true;
+            // The accepted layer is the only place that knows which slash commands
+            // this host actually got, so report them from it. Anything missing here
+            // is missing from the host's command palette too. It goes to the
+            // diagnostic log as well as the console because a TUI host owns the
+            // screen and drops plugin console output.
+            const registered = `registered slash commands: ${buildKeymapLayer()
+                .commands.map((command) => command.slash.name)
+                .join(" ")}`;
+            log(`[magic-context] ${registered}`);
+            // Startup lines are worth an immediate write: a TUI that exits or is
+            // killed before the next buffer flush would otherwise leave no record
+            // of which commands this host received.
+            flushLogger();
+            console.info(`[magic-context] ${registered}`);
+            return true;
+        } catch (error) {
+            if (!(error instanceof Error) || error.message !== "Keymap.Provider is missing")
+                throw error;
+            return false;
+        }
+    };
+    let unregisterKeymapSlot: (() => void) | undefined;
+    if (!registerKeymapLayer()) {
+        unregisterKeymapSlot = context.ui.slot({
+            append: "app",
+            render: () => {
+                let registered = false;
+                try {
+                    registered = registerKeymapLayer();
+                } catch (error) {
+                    console.warn("[magic-context] keymap.layer registration failed", error);
+                }
+                if (!registered && !keymapGapLogged) {
+                    keymapGapLogged = true;
+                    console.warn(
+                        "[magic-context] OpenCode 2 keymap.layer is unavailable; /ctx-status, /ctx-recomp, /ctx-dream, /ctx-flush, /ctx-embed and /ctx-wrapup were not registered",
+                    );
+                }
+                return null;
+            },
+        });
+    }
+
+    // Only the text projection needs the sidebar snapshot store; the mounted
+    // component keeps its own snapshot and subscribes to the same event stream
+    // itself.
+    const stopListening = context.data.listen(({ details }) => {
+        if (mountedSidebar) return;
+        const sessionID = eventSessionID(details);
+        if (sessionID) void refresh(sessionID, true);
+    });
+
+    const handleNotification = async (notification: SocketNotification): Promise<boolean> => {
+        const target = notification.sessionId ?? currentSessionID(context);
+        if (notification.sessionId && notification.sessionId !== currentSessionID(context))
+            return false;
+        if (notification.type === "toast") {
+            const payload = notification.payload;
+            context.ui.toast.show({
+                title: typeof payload.title === "string" ? payload.title : undefined,
+                message: String(payload.message ?? ""),
+                variant:
+                    payload.variant === "success" ||
+                    payload.variant === "warning" ||
+                    payload.variant === "error"
+                        ? payload.variant
+                        : "info",
+                duration: typeof payload.duration === "number" ? payload.duration : undefined,
+            });
+            return true;
+        }
+        if (notification.type !== "action") return false;
+        if (notification.payload.action === "show-status-dialog") {
+            return showStatus(target);
+        }
+        if (notification.payload.action === "show-recomp-dialog") return showRecomp(target);
+        if (notification.payload.action === "refresh-sidebar" && target) {
+            if (mountedSidebar) mountedSidebar.refresh();
+            else await refresh(target, true);
+            return true;
+        }
+        if (notification.payload.action === "show-result-dialog") {
+            await context.ui.dialog.alert({
+                title: String(notification.payload.title ?? "Magic Context"),
+                message: String(notification.payload.message ?? ""),
+            });
+            return true;
+        }
+        return false;
+    };
+
+    startNotificationSocket({
+        getSessionId: () => currentSessionID(context),
+        onNotification: handleNotification,
+    });
+    console.info("[magic-context] @cortexkit/opencode-magic-context v2 TUI setup");
+
+    return () => {
+        unregisterSlot();
+        mountedSidebar?.dispose();
+        mountedSidebar = null;
+        statusDialog = null;
+        unregisterKeymapSlot?.();
+        stopListening();
+        stopNotificationSocket();
+        closeRpc();
+        inflight.clear();
+        refreshedAt.clear();
+    };
+}
+
+export async function setup(context: V2TuiContext): Promise<() => void> {
+    return setupWithJsx(context, jsx);
+}
+
+export default { id: "opencode-magic-context", setup };

package/src/v2/tui/load-compiled-sidebar.d.mts

@@ -0,0 +1,59 @@
+/** Typed view of load-compiled-sidebar.mjs; see that file for why it is untyped JS. */
+
+/** The colour table the OpenCode 1 sidebar reads (OpenTUI RGBA or a hex string). */
+export type V1ThemeColor = { r: number; g: number; b: number; a?: number } | string;
+
+export type V1Theme = Record<
+    | "text"
+    | "textMuted"
+    | "accent"
+    | "background"
+    | "borderActive"
+    | "error"
+    | "warning"
+    | "success",
+    V1ThemeColor
+>;
+
+/**
+ * The v1 event object as the sidebar component reads it. It only ever pulls a
+ * session id out of these three fields.
+ */
+export interface V1Event {
+    readonly properties: {
+        readonly sessionID: string;
+        readonly info: { readonly id: string; readonly sessionID: string };
+    };
+}
+
+/** The slice of OpenCode 1's `TuiPluginApi` the sidebar component actually uses. */
+export interface V1SidebarApi {
+    readonly state: { readonly path: { readonly directory: string } };
+    readonly renderer: { requestRender(): void };
+    readonly event: { on(type: string, handler: (event: V1Event) => void): () => void };
+}
+
+export interface V1SidebarSlot {
+    dispose(): void;
+    slots: {
+        sidebar_content(
+            context: { readonly theme: { readonly current: V1Theme } },
+            value: { readonly session_id: string },
+        ): unknown;
+    };
+}
+
+export interface CompiledSidebarComponent {
+    createSidebarContentSlot(api: V1SidebarApi): V1SidebarSlot;
+    refreshSidebarSnapshot(): void;
+}
+
+export interface CompiledSidebarData {
+    initRpcClient(directory: string): void;
+    closeRpc(): void;
+}
+
+export declare function loadCompiledSidebar(): Promise<{
+    component: CompiledSidebarComponent;
+    data: CompiledSidebarData;
+}>;

package/src/v2/tui/load-compiled-sidebar.mjs

@@ -0,0 +1,24 @@
+// Loads the precompiled OpenCode 1 sidebar for the OpenCode 2 slot mount.
+//
+// This lives in a .mjs file on purpose. `src/tui-compiled/slots/sidebar-content.tsx`
+// is Solid-transform output that the package never typechecks or compiles — it
+// is shipped verbatim and executed by the host — and a TypeScript file importing
+// a .tsx path forces `--jsx` on the whole program, which would pull that
+// generated file into the type graph. Keeping the import here is the same
+// arrangement `src/tui/entry.mjs` already uses for the v1 entry; the typed view
+// of this module is the sibling load-compiled-sidebar.d.mts.
+//
+// Explicit extensions match entry.mjs: the host resolves these paths directly,
+// with no bundler step to fill an extension in.
+
+/**
+ * Imports the compiled sidebar component and the RPC data-layer copy that
+ * compiled tree carries. Rejects when the host registers no
+ * `opentui:runtime-module:*` virtual modules to resolve the component's runtime
+ * imports through; the caller answers that case with the text projection.
+ */
+export async function loadCompiledSidebar() {
+    const component = await import("../../tui-compiled/slots/sidebar-content.tsx");
+    const data = await import("../../tui-compiled/data/context-db.ts");
+    return { component, data };
+}

package/src/v2/tui/load-compiled-status-dialog.d.mts

@@ -0,0 +1,17 @@
+/** Typed view of load-compiled-status-dialog.mjs; see that file for why it is untyped JS. */
+import type { StatusDetail } from "../../shared/rpc-types";
+import type { V1Theme } from "./load-compiled-sidebar.d.mts";
+
+/** The slice of OpenCode 1's `TuiPluginApi` the status dialog component reads. */
+export interface V1StatusDialogApi {
+    readonly theme: { readonly current: V1Theme };
+}
+
+export interface CompiledStatusDialog {
+    StatusDialog(props: {
+        readonly api: V1StatusDialogApi;
+        readonly s: StatusDetail;
+    }): unknown;
+}
+
+export declare function loadCompiledStatusDialog(): Promise<CompiledStatusDialog>;

package/src/v2/tui/load-compiled-status-dialog.mjs

@@ -0,0 +1,16 @@
+// Loads the precompiled OpenCode 1 status dialog for the OpenCode 2 dialog surface.
+//
+// Same arrangement, and same reasons, as load-compiled-sidebar.mjs next to it:
+// `src/tui-compiled/dialogs/status-dialog.tsx` is Solid-transform output that this
+// package never typechecks or compiles, and a TypeScript file importing a .tsx
+// path would force `--jsx` on the whole program and pull that generated file into
+// the type graph. The typed view of this module is load-compiled-status-dialog.d.mts.
+
+/**
+ * Imports the compiled status dialog component. Rejects when the host registers
+ * no `opentui:runtime-module:*` virtual modules to resolve the component's
+ * runtime imports through; the caller answers that case with the text dialog.
+ */
+export async function loadCompiledStatusDialog() {
+    return await import("../../tui-compiled/dialogs/status-dialog.tsx");
+}