@cortexkit/opencode-magic-context 0.42.6 → 0.43.0

package/src/v2/tui/host-contract.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { resolve } from "node:path";
 import { Host } from "@opencode/plugin/host";
 import { setupWithJsx } from "./index";
-import type { V2SidebarState, V2TuiContext } from "./types";
+import type { V2SidebarState, V2SlotClaim, V2TuiContext } from "./types";
 
 const temporary: string[] = [];
 afterEach(() => {
@@ -13,7 +13,7 @@ afterEach(() => {
 });
 
 function v2Context() {
-    const claims: Array<{ render: (input: { sessionID: string }) => unknown }> = [];
+    const claims: V2SlotClaim[] = [];
     const layers: Array<ReturnType<Parameters<V2TuiContext["keymap"]["layer"]>[0]>> = [];
     const cleanups: Array<() => void> = [];
     const state: V2SidebarState = { snapshots: {} };
@@ -125,31 +125,80 @@ test("GA 2.0.5 resolves ./tui and executes the union setup contract", async () =
     expect(typeof loaded.default.setup).toBe("function");
     const fixture = v2Context();
     const cleanup = await setupWithJsx(fixture.context, (type, props) => ({ type, props }));
-    expect(fixture.claims).toHaveLength(1);
-    expect(fixture.claims[0]!.render({ sessionID: "ses-v2-tui" })).toEqual({
+    expect(fixture.claims.map((claim) => claim.append)).toEqual(["sidebar.content"]);
+    const sidebarClaim = fixture.claims[0]!;
+    if (sidebarClaim.append !== "sidebar.content") throw new Error("expected the sidebar claim");
+    expect(sidebarClaim.render({ sessionID: "ses-v2-tui" })).toEqual({
         type: "text",
         props: { children: expect.stringContaining("Magic Context") },
     });
     expect(fixture.layers[0]!.commands.map((command) => command.slash.name)).toEqual([
         "ctx-status",
         "ctx-recomp",
+        "ctx-dream",
+        "ctx-flush",
+        "ctx-embed",
+        "ctx-wrapup",
     ]);
     cleanup();
 });
 
-test("GA 2.0.5 records its unbound keymap.layer gap without losing the sidebar", async () => {
+test("GA 2.0.5 registers the keymap layer from the app slot when setup runs outside the provider", async () => {
     const fixture = v2Context();
+    let providerAvailable = false;
     Object.assign(fixture.context.keymap, {
-        layer: () => {
-            throw new Error("Keymap.Provider is missing");
+        layer: (input: () => unknown) => {
+            if (!providerAvailable) throw new Error("Keymap.Provider is missing");
+            fixture.layers.push(input() as never);
         },
     });
     const cleanup = await setupWithJsx(fixture.context, (type, props) => ({ type, props }));
-    expect(fixture.claims).toHaveLength(1);
+    expect(fixture.claims.map((claim) => claim.append)).toEqual(["sidebar.content", "app"]);
     expect(fixture.layers).toHaveLength(0);
+
+    // The app slot render executes inside the component tree, where the provider resolves.
+    providerAvailable = true;
+    const appClaim = fixture.claims.find((claim) => claim.append === "app");
+    if (appClaim?.append !== "app") throw new Error("expected the app slot claim");
+    appClaim.render({});
+    expect(
+        fixture.layers.map((layer) => layer.commands.map((command) => command.slash.name)),
+    ).toEqual([["ctx-status", "ctx-recomp", "ctx-dream", "ctx-flush", "ctx-embed", "ctx-wrapup"]]);
+    // Repeated renders must not stack duplicate layers.
+    appClaim.render({});
+    expect(fixture.layers).toHaveLength(1);
     cleanup();
 });
 
+test("GA 2.0.5 keeps the sidebar when the app-slot keymap registration also fails", async () => {
+    const fixture = v2Context();
+    Object.assign(fixture.context.keymap, {
+        layer: () => {
+            throw new Error("Keymap.Provider is missing");
+        },
+    });
+    const warnings: string[] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+        warnings.push(args.map(String).join(" "));
+    };
+    try {
+        const cleanup = await setupWithJsx(fixture.context, (type, props) => ({ type, props }));
+        expect(fixture.claims.map((claim) => claim.append)).toEqual(["sidebar.content", "app"]);
+        const appClaim = fixture.claims.find((claim) => claim.append === "app");
+        if (appClaim?.append !== "app") throw new Error("expected the app slot claim");
+        appClaim.render({});
+        appClaim.render({});
+        expect(fixture.layers).toHaveLength(0);
+        expect(
+            warnings.filter((line) => line.includes("keymap.layer is unavailable")),
+        ).toHaveLength(1);
+        cleanup();
+    } finally {
+        console.warn = originalWarn;
+    }
+});
+
 test("OpenCode 1.18.30 TUI loader projection executes unchanged sidebar registration", async () => {
     // v1.18.30 packages/opencode/src/plugin/shared.ts:272-304 reads only id,
     // server and tui, rejects a simultaneous server+tui pair, and returns the

package/src/v2/tui/index.ts

@@ -1,19 +1,30 @@
 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 type { V2SidebarState, V2TuiContext } from "./types";
+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>();
@@ -25,8 +36,30 @@ function compactTokens(value: number): string {
     return String(value);
 }
 
-function sidebarText(snapshot: SidebarSnapshot | undefined): string {
+/**
+ * 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)}`
@@ -41,18 +74,42 @@ function sidebarText(snapshot: SidebarSnapshot | undefined): string {
     ].join("\n");
 }
 
-function statusText(detail: StatusDetail): string {
+/**
+ * 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");
 }
@@ -62,25 +119,6 @@ function currentSessionID(context: V2TuiContext): string | null {
     return route.type === "session" && route.sessionID ? route.sessionID : null;
 }
 
-function eventSessionID(event: unknown): string | undefined {
-    if (typeof event !== "object" || event === null) return undefined;
-    const record = event as Record<string, unknown>;
-    const data =
-        typeof record.data === "object" && record.data !== null
-            ? (record.data as Record<string, unknown>)
-            : record;
-    for (const key of ["sessionID", "sessionId", "id"]) {
-        if (typeof data[key] === "string") return data[key];
-    }
-    const info = data.info;
-    if (typeof info === "object" && info !== null) {
-        const nested = info as Record<string, unknown>;
-        if (typeof nested.sessionID === "string") return nested.sessionID;
-        if (typeof nested.id === "string") return nested.id;
-    }
-    return undefined;
-}
-
 type JsxFactory = (type: string, props: Record<string, unknown>) => unknown;
 
 export async function setupWithJsx(context: V2TuiContext, jsx: JsxFactory): Promise<() => void> {
@@ -108,7 +146,7 @@ export async function setupWithJsx(context: V2TuiContext, jsx: JsxFactory): Prom
         }
     };
 
-    const showStatus = async (diagnostics = false, target = currentSessionID(context)) => {
+    const showStatus = async (target = currentSessionID(context)) => {
         if (!target) {
             context.ui.toast.show({ message: "No active session", variant: "warning" });
             return false;
@@ -122,8 +160,21 @@ export async function setupWithJsx(context: V2TuiContext, jsx: JsxFactory): Prom
             });
             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: diagnostics ? "Magic Context diagnostics" : "Magic Context status",
+            title: "Magic Context status",
             message: statusText(result.detail),
         });
         return true;
@@ -162,49 +213,249 @@ export async function setupWithJsx(context: V2TuiContext, jsx: JsxFactory): Prom
         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: ({ sessionID }) => {
-            void refresh(sessionID);
-            return jsx("text", { children: sidebarText(sidebar.snapshots[sessionID]) });
+        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]) });
         },
     });
 
-    try {
-        context.keymap.layer(() => ({
-            mode: "global",
-            commands: [
-                {
-                    id: "magic-context.status",
-                    title: "Magic Context: Status",
-                    group: "Magic Context",
-                    palette: true,
-                    slash: { name: "ctx-status", arguments: true },
-                    run: async (input) => {
-                        await showStatus(input?.trim().toLowerCase() === "diagnostics");
-                    },
+    // 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.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);
                 },
-            ],
-        }));
-    } catch (error) {
-        if (!(error instanceof Error) || error.message !== "Keymap.Provider is missing")
-            throw error;
-        console.warn(
-            "[magic-context] OpenCode 2.0.5 keymap.layer is unavailable during plugin setup; /ctx-status and /ctx-recomp were not registered",
-        );
+            },
+            {
+                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);
     });
@@ -230,11 +481,12 @@ export async function setupWithJsx(context: V2TuiContext, jsx: JsxFactory): Prom
         }
         if (notification.type !== "action") return false;
         if (notification.payload.action === "show-status-dialog") {
-            return showStatus(notification.payload.diagnostics === true, target);
+            return showStatus(target);
         }
         if (notification.payload.action === "show-recomp-dialog") return showRecomp(target);
         if (notification.payload.action === "refresh-sidebar" && target) {
-            await refresh(target, true);
+            if (mountedSidebar) mountedSidebar.refresh();
+            else await refresh(target, true);
             return true;
         }
         if (notification.payload.action === "show-result-dialog") {
@@ -255,6 +507,10 @@ export async function setupWithJsx(context: V2TuiContext, jsx: JsxFactory): Prom
 
     return () => {
         unregisterSlot();
+        mountedSidebar?.dispose();
+        mountedSidebar = null;
+        statusDialog = null;
+        unregisterKeymapSlot?.();
         stopListening();
         stopNotificationSocket();
         closeRpc();

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 };
+}