@mirrowel/opencode-subagent-explorer 0.1.0-dev.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Agent Variants contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# @mirrowel/opencode-subagent-explorer
+
+[![npm](https://img.shields.io/npm/v/@mirrowel/opencode-subagent-explorer)](https://www.npmjs.com/package/@mirrowel/opencode-subagent-explorer)
+[![license](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+An [OpenCode](https://opencode.ai) plugin for exploring — and cleaning up — the subagent sessions of your current session.
+
+Subagent (task tool) sessions pile up fast: every task call spawns a child session with its own messages and history, including hidden background ones (Magic Context's historian passes, plugin-registered agents). They live in OpenCode's database even after the conversation moved on. This plugin gives you a tree view of all of them, per-session details, single deletion, and a one-key cleanup that removes every idle session in the current tree.
+
+<!-- TODO screenshot: docs/screenshots/tree.png -->
+
+## What it looks like
+
+Open the palette and run **Subagent Explorer: Open** (or `/subagent-explorer`):
+
+- The current session's full subagent tree — nested children included, sorted by creation time
+- Per row: agent, title, running state (`▶` green while busy), last activity, `[hidden]` badge for background agents
+- `i` — details: agent, status, times, message count, last model, first prompt
+- `enter` — delete one session (running ones ask a red extra confirmation)
+- `c` — cleanup: delete every idle subagent session in the tree, sparing running ones
+- `r` — refresh · `s` — explore another session's tree
+
+Deleting a session permanently removes it, its messages, and its history. The parent session keeps the task result text — only the "view subagent" jump target is lost.
+
+<!-- TODO screenshot: docs/screenshots/details.png -->
+
+## Install
+
+```jsonc
+// ~/.config/opencode/opencode.json
+{
+  "plugin": ["@mirrowel/opencode-subagent-explorer"]
+}
+```
+
+The plugin wires its TUI side automatically (a matching `tui.json` entry is mirrored at the same config level). Works on OpenCode v1 and the v2 beta.
+
+### With Config Studio
+
+If you use [Config Studio](https://github.com/Mirrowel/opencode-config-studio), the explorer integrates into its **Tools** section instead — enable the module there and the standalone entry stands down.
+
+## How it works
+
+- Sessions are listed via OpenCode's session API and walked by `parentID` from the current session (the TUI router's session; newest session as fallback)
+- Running sessions are detected through the live active-session map — never guessed from timestamps
+- Hidden/background classification: agents flagged `hidden` in your config, plus runtime-registered agents OpenCode doesn't expose
+- All host calls are timeout-bounded and fail soft; a host without a session API gets a clear notice instead of a hang
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Subagent Explorer server plugin (v1).
+ *
+ * The explorer is a TUI-driven tool: the server side exists purely so a
+ * single opencode.json registration loads the plugin (and self-wires the
+ * matching tui.json entry - see selfwire.ts). No hooks are registered; the
+ * plugin never intercepts runtime behavior.
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+import { ensureTuiRegistration, isSubagentExplorerSpec } from "./selfwire.js";
+export declare const plugin: Plugin;
+export declare const __testInternals: {
+    ensureTuiRegistration: typeof ensureTuiRegistration;
+    isSubagentExplorerSpec: typeof isSubagentExplorerSpec;
+};

package/dist/index.js

@@ -0,0 +1,20 @@
+/**
+ * Subagent Explorer server plugin (v1).
+ *
+ * The explorer is a TUI-driven tool: the server side exists purely so a
+ * single opencode.json registration loads the plugin (and self-wires the
+ * matching tui.json entry - see selfwire.ts). No hooks are registered; the
+ * plugin never intercepts runtime behavior.
+ */
+import { ensureTuiRegistration, isSubagentExplorerSpec } from "./selfwire.js";
+export const plugin = async (input) => {
+    // File-scan only, wrapped in try/catch: never blocks or breaks startup.
+    try {
+        ensureTuiRegistration({ directory: input.directory, worktree: input.worktree, env: process.env });
+    }
+    catch {
+        /* self-wiring is best-effort */
+    }
+    return {};
+};
+export const __testInternals = { ensureTuiRegistration, isSubagentExplorerSpec };

package/dist/palette-category.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared palette category for Mirrowel OpenCode plugins loaded in the same
+ * session. Every family plugin declares its own label into a process-wide
+ * registry at TUI activation; a delayed reconciler joins all declared labels
+ * (alphabetical, deterministic) and writes the join into every registered
+ * command object, so the palette shows one combined section. A plugin loaded
+ * alone keeps its own name; third-party plugins never declare and stay out.
+ *
+ * Labels are defined only in each plugin's entry point - this module carries
+ * no per-plugin data. Keep the logic copies in sync across family repos.
+ */
+type CategorizedCommand = {
+    category?: string;
+    group?: string;
+};
+/**
+ * Declares this plugin's category label and attaches command objects whose
+ * `category` field is kept in sync. Returns the current join, so the very
+ * first registration already renders correctly even before reconcilers run.
+ */
+export declare function declarePaletteCategory(label: string, ...commands: CategorizedCommand[]): string;
+/** Live join for callback-style command registration (reads fresh each call). */
+export declare function currentPaletteCategory(): string;
+/** Writes the current join into every declared command (idempotent). */
+export declare function reconcilePaletteCategories(): void;
+/** Delayed reconciles so later-activating siblings join before the user opens the palette. */
+export declare function schedulePaletteReconcile(delaysMs?: readonly number[]): void;
+/** Tests only: drop all declarations. */
+export declare function __resetPaletteRegistry(): void;
+export {};

package/dist/palette-category.js

@@ -0,0 +1,72 @@
+/**
+ * Shared palette category for Mirrowel OpenCode plugins loaded in the same
+ * session. Every family plugin declares its own label into a process-wide
+ * registry at TUI activation; a delayed reconciler joins all declared labels
+ * (alphabetical, deterministic) and writes the join into every registered
+ * command object, so the palette shows one combined section. A plugin loaded
+ * alone keeps its own name; third-party plugins never declare and stay out.
+ *
+ * Labels are defined only in each plugin's entry point - this module carries
+ * no per-plugin data. Keep the logic copies in sync across family repos.
+ */
+const REGISTRY_KEY = Symbol.for("mirrowel.opencode.paletteCategory");
+function registry() {
+    const globals = globalThis;
+    if (!globals[REGISTRY_KEY])
+        globals[REGISTRY_KEY] = { entries: [] };
+    return globals[REGISTRY_KEY];
+}
+function joinLabels(labels) {
+    if (labels.length <= 1)
+        return labels[0] ?? "";
+    return `${labels.slice(0, -1).join(", ")} & ${labels[labels.length - 1]}`;
+}
+function joinedCategory() {
+    const labels = [...new Set(registry().entries.map((entry) => entry.label))].sort((a, b) => a.localeCompare(b));
+    return joinLabels(labels);
+}
+/**
+ * Declares this plugin's category label and attaches command objects whose
+ * `category` field is kept in sync. Returns the current join, so the very
+ * first registration already renders correctly even before reconcilers run.
+ */
+export function declarePaletteCategory(label, ...commands) {
+    const reg = registry();
+    let entry = reg.entries.find((item) => item.label === label);
+    if (!entry) {
+        entry = { label, commands: [] };
+        reg.entries.push(entry);
+    }
+    for (const command of commands) {
+        if (command && !entry.commands.includes(command))
+            entry.commands.push(command);
+    }
+    reconcilePaletteCategories();
+    return joinedCategory();
+}
+/** Live join for callback-style command registration (reads fresh each call). */
+export function currentPaletteCategory() {
+    return joinedCategory();
+}
+/** Writes the current join into every declared command (idempotent). */
+export function reconcilePaletteCategories() {
+    const category = joinedCategory();
+    for (const entry of registry().entries) {
+        for (const command of entry.commands) {
+            command.category = category;
+            command.group = category;
+        }
+    }
+}
+/** Delayed reconciles so later-activating siblings join before the user opens the palette. */
+export function schedulePaletteReconcile(delaysMs = [2000, 6000]) {
+    for (const delay of delaysMs) {
+        const timer = setTimeout(() => reconcilePaletteCategories(), delay);
+        timer.unref?.();
+    }
+}
+/** Tests only: drop all declarations. */
+export function __resetPaletteRegistry() {
+    ;
+    globalThis[REGISTRY_KEY] = undefined;
+}

package/dist/selfwire.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Self-wiring for the subagent-explorer TUI (v1 hosts only).
+ *
+ * OpenCode loads server plugins from the `plugin` array in opencode.json
+ * layers but TUI plugins only from tui.json layers. When subagent-explorer
+ * is registered standalone (opencode.json) without a matching tui.json
+ * entry, the explorer command never loads. ensureTuiRegistration() mirrors
+ * the server registration into tui.json AT THE SAME CONFIG LEVEL
+ * (global -> global, project -> project) with the same auto-correct
+ * semantics as Config Studio's selfwire:
+ *
+ * - identity matching: any checkout counts (repo folder named plain
+ *   `subagent-explorer` or `opencode-subagent-explorer`), not just this
+ *   running instance's directory
+ * - the tui entry must MATCH the server registration; local checkouts win
+ *   over npm installs when both are registered
+ * - stale mirrors (tui entries at levels without a server registration) are
+ *   removed; duplicates are deduped
+ *
+ * When Config Studio is registered anywhere (it can embed subagent-explorer
+ * and provides the Tools menu entry), selfwiring is skipped entirely so the
+ * two never fight over the TUI slot. v2 hosts never run this module: they
+ * auto-discover ./tui from server-declared plugins, and the v2 setup does
+ * not import it.
+ */
+export declare function isSubagentExplorerSpec(spec: unknown): spec is string;
+export declare function isConfigStudioSpec(spec: unknown): spec is string;
+export type WireResult = {
+    status: "skipped-studio";
+} | {
+    status: "already-wired";
+    spec: string;
+} | {
+    status: "wired";
+    spec: string;
+    target: string;
+} | {
+    status: "corrected";
+    spec: string;
+    target: string;
+} | {
+    status: "not-registered";
+} | {
+    status: "failed";
+    error: string;
+};
+/**
+ * Mirrors the standalone subagent-explorer server registration into
+ * tui.json (same config level). No-op when Config Studio is registered
+ * anywhere - it embeds subagent-explorer and provides the Tools entry
+ * itself.
+ */
+export declare function ensureTuiRegistration(input?: {
+    directory?: string;
+    worktree?: string;
+    env?: NodeJS.ProcessEnv;
+}): WireResult;

package/dist/selfwire.js

@@ -0,0 +1,321 @@
+/**
+ * Self-wiring for the subagent-explorer TUI (v1 hosts only).
+ *
+ * OpenCode loads server plugins from the `plugin` array in opencode.json
+ * layers but TUI plugins only from tui.json layers. When subagent-explorer
+ * is registered standalone (opencode.json) without a matching tui.json
+ * entry, the explorer command never loads. ensureTuiRegistration() mirrors
+ * the server registration into tui.json AT THE SAME CONFIG LEVEL
+ * (global -> global, project -> project) with the same auto-correct
+ * semantics as Config Studio's selfwire:
+ *
+ * - identity matching: any checkout counts (repo folder named plain
+ *   `subagent-explorer` or `opencode-subagent-explorer`), not just this
+ *   running instance's directory
+ * - the tui entry must MATCH the server registration; local checkouts win
+ *   over npm installs when both are registered
+ * - stale mirrors (tui entries at levels without a server registration) are
+ *   removed; duplicates are deduped
+ *
+ * When Config Studio is registered anywhere (it can embed subagent-explorer
+ * and provides the Tools menu entry), selfwiring is skipped entirely so the
+ * two never fight over the TUI slot. v2 hosts never run this module: they
+ * auto-discover ./tui from server-declared plugins, and the v2 setup does
+ * not import it.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { parse, stringify } from "comment-json";
+const EXPLORER_NPM = "@mirrowel/opencode-subagent-explorer";
+const STUDIO_NPM = "@mirrowel/opencode-config-studio";
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+function specPathSegments(spec) {
+    if (!spec.startsWith("file:"))
+        return undefined;
+    try {
+        let url = spec;
+        if (!url.startsWith("file:///") && url.startsWith("file://"))
+            url = `file:///${url.slice("file://".length)}`;
+        return normalizePath(new URL(url).pathname);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isLocalSpec(spec) {
+    return spec.startsWith("file:") || /^([a-zA-Z]:[\\/]|\/)/.test(spec);
+}
+export function isSubagentExplorerSpec(spec) {
+    if (typeof spec !== "string" || spec.length === 0)
+        return false;
+    if (spec === EXPLORER_NPM || spec.startsWith(`${EXPLORER_NPM}@`))
+        return true;
+    const path = specPathSegments(spec);
+    if (!path)
+        return false;
+    if (path.endsWith("/opencode-subagent-explorer") || path.endsWith("/subagent-explorer"))
+        return true;
+    // Cache/wrapper layouts: <base>/@mirrowel/opencode-subagent-explorer@<tag>[/node_modules/...]
+    return path.includes("/@mirrowel/opencode-subagent-explorer") || path.includes("/node_modules/@mirrowel/opencode-subagent-explorer");
+}
+export function isConfigStudioSpec(spec) {
+    if (typeof spec !== "string" || spec.length === 0)
+        return false;
+    if (spec === STUDIO_NPM || spec.startsWith(`${STUDIO_NPM}@`))
+        return true;
+    const path = specPathSegments(spec);
+    if (!path)
+        return false;
+    return path.endsWith("/opencode-config-studio");
+}
+function specStrings(data) {
+    const result = [];
+    for (const key of ["plugin", "plugins"]) {
+        const array = data[key];
+        if (!Array.isArray(array))
+            continue;
+        for (const entry of array) {
+            const spec = typeof entry === "string"
+                ? entry
+                : Array.isArray(entry) && typeof entry[0] === "string"
+                    ? entry[0]
+                    : entry && typeof entry === "object" && typeof entry.package === "string"
+                        ? entry.package
+                        : undefined;
+            if (spec !== undefined)
+                result.push(spec);
+        }
+    }
+    return result;
+}
+function readJsonc(path) {
+    try {
+        if (!existsSync(path))
+            return {};
+        return parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function sameDir(a, b) {
+    return normalizePath(a) === normalizePath(b);
+}
+function levelDirOf(configPath) {
+    let dir = dirname(configPath);
+    if (basename(dir) === ".opencode")
+        dir = dirname(dir);
+    return dir;
+}
+function globalConfigDir(env) {
+    if (env?.["OPENCODE_CONFIG_DIR"])
+        return env["OPENCODE_CONFIG_DIR"];
+    if (env?.["XDG_CONFIG_HOME"])
+        return join(env["XDG_CONFIG_HOME"], "opencode");
+    const home = process.env.USERPROFILE ?? process.env.HOME ?? "";
+    return join(home, ".config", "opencode");
+}
+function opencodeLayerPaths(input) {
+    const paths = [];
+    const pushDir = (dir) => {
+        for (const candidate of [join(dir, "opencode.json"), join(dir, "opencode.jsonc"), join(dir, ".opencode", "opencode.json"), join(dir, ".opencode", "opencode.jsonc")]) {
+            if (existsSync(candidate) && !paths.includes(candidate))
+                paths.push(candidate);
+        }
+    };
+    const globalDir = globalConfigDir(input.env);
+    if (input.env?.["OPENCODE_CONFIG"]) {
+        if (existsSync(input.env["OPENCODE_CONFIG"]))
+            paths.push(input.env["OPENCODE_CONFIG"]);
+    }
+    else {
+        pushDir(globalDir);
+    }
+    if (input.directory && input.worktree && input.directory.startsWith(input.worktree)) {
+        let current = input.directory;
+        for (let guard = 0; guard < 64 && current; guard++) {
+            pushDir(current);
+            if (current === input.worktree || current === dirname(current))
+                break;
+            current = dirname(current);
+        }
+    }
+    return paths;
+}
+function tuiLayerPaths(input) {
+    const paths = [];
+    const globalDir = globalConfigDir(input.env);
+    const globalTui = join(globalDir, "tui.json");
+    if (existsSync(globalTui))
+        paths.push(globalTui);
+    const envTui = input.env?.["OPENCODE_TUI_CONFIG"];
+    if (envTui && existsSync(envTui))
+        paths.push(envTui);
+    if (input.directory && input.worktree && input.directory.startsWith(input.worktree)) {
+        let current = input.directory;
+        for (let guard = 0; guard < 64 && current; guard++) {
+            for (const candidate of [join(current, "tui.json"), join(current, ".opencode", "tui.json")]) {
+                if (existsSync(candidate) && !paths.includes(candidate))
+                    paths.push(candidate);
+            }
+            if (current === input.worktree || current === dirname(current))
+                break;
+            current = dirname(current);
+        }
+    }
+    return paths;
+}
+function ownIndices(tuiPath) {
+    const data = readJsonc(tuiPath);
+    const plugin = data["plugin"];
+    if (!Array.isArray(plugin))
+        return [];
+    const indices = [];
+    plugin.forEach((entry, index) => {
+        const spec = typeof entry === "string" ? entry : Array.isArray(entry) && typeof entry[0] === "string" ? entry[0] : undefined;
+        if (spec !== undefined && isSubagentExplorerSpec(spec))
+            indices.push(index);
+    });
+    return indices;
+}
+function preferLocal(specs) {
+    const local = specs.filter(isLocalSpec);
+    const npm = specs.filter((spec) => !local.includes(spec));
+    return [...local, ...npm];
+}
+function atomicWrite(path, content, stateDir) {
+    try {
+        const backupDir = join(stateDir, "selfwire-backups");
+        mkdirSync(backupDir, { recursive: true });
+        if (existsSync(path)) {
+            const backup = join(backupDir, `${basename(path)}.${Date.now()}.bak`);
+            writeFileSync(backup, readFileSync(path, "utf8"), "utf8");
+        }
+        const temp = `${path}.se-tmp`;
+        writeFileSync(temp, content, "utf8");
+        renameSync(temp, path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Mirrors the standalone subagent-explorer server registration into
+ * tui.json (same config level). No-op when Config Studio is registered
+ * anywhere - it embeds subagent-explorer and provides the Tools entry
+ * itself.
+ */
+export function ensureTuiRegistration(input = {}) {
+    try {
+        const opencodeLayers = opencodeLayerPaths(input);
+        const tuiLayers = tuiLayerPaths(input);
+        // Config Studio present anywhere (server or tui layers) -> stand down.
+        for (const layer of [...opencodeLayers, ...tuiLayers]) {
+            if (specStrings(readJsonc(layer)).some((spec) => isConfigStudioSpec(spec))) {
+                return { status: "skipped-studio" };
+            }
+        }
+        const registrations = opencodeLayers
+            .map((path) => ({
+            path,
+            level: levelDirOf(path),
+            specs: specStrings(readJsonc(path)).filter((spec) => isSubagentExplorerSpec(spec)),
+        }))
+            .filter((layer) => layer.specs.length > 0);
+        if (registrations.length === 0)
+            return { status: "not-registered" };
+        const preferAt = (layers) => {
+            const ordered = [...layers].sort((a, b) => {
+                const aLocal = a.specs.some(isLocalSpec);
+                const bLocal = b.specs.some(isLocalSpec);
+                if (aLocal !== bLocal)
+                    return aLocal ? -1 : 1;
+                return 0;
+            });
+            const first = ordered[0];
+            return first ? preferLocal(first.specs)[0] : undefined;
+        };
+        const wanted = preferAt(registrations);
+        if (!wanted)
+            return { status: "not-registered" };
+        const wantedLevel = registrations.find((layer) => layer.specs.includes(wanted))?.level ?? globalConfigDir(input.env);
+        const target = sameDir(wantedLevel, globalConfigDir(input.env))
+            ? join(globalConfigDir(input.env), "tui.json")
+            : join(wantedLevel, "tui.json");
+        const stateDir = join(globalConfigDir(input.env), "subagent-explorer");
+        let wired = false;
+        let corrected = false;
+        const seen = new Set();
+        const fixTuiFile = (tuiPath, level) => {
+            if (seen.has(tuiPath))
+                return;
+            seen.add(tuiPath);
+            const indices = ownIndices(tuiPath);
+            if (indices.length === 0)
+                return;
+            const levelLayers = registrations.filter((layer) => sameDir(layer.level, level));
+            const data = readJsonc(tuiPath);
+            const plugin = data["plugin"];
+            if (!Array.isArray(plugin))
+                return;
+            if (levelLayers.length === 0) {
+                // Stale mirror: no server registration at this level.
+                for (const index of [...indices].sort((a, b) => b - a))
+                    plugin.splice(index, 1);
+                corrected = true;
+            }
+            else {
+                const wantedHere = preferAt(levelLayers) ?? wanted;
+                const keepIndex = indices[0];
+                let changed = false;
+                if (indices.length > 1) {
+                    for (const index of [...indices].slice(1).sort((a, b) => b - a))
+                        plugin.splice(index, 1);
+                    changed = true;
+                }
+                const entry = plugin[keepIndex];
+                const spec = typeof entry === "string" ? entry : Array.isArray(entry) && typeof entry[0] === "string" ? entry[0] : undefined;
+                if (spec !== wantedHere) {
+                    if (Array.isArray(entry))
+                        entry[0] = wantedHere;
+                    else
+                        plugin[keepIndex] = wantedHere;
+                    changed = true;
+                }
+                if (changed)
+                    corrected = true;
+                else
+                    return;
+            }
+            if (!atomicWrite(tuiPath, stringify(data, null, 2) + "\n", stateDir)) {
+                throw new Error(`failed to write ${tuiPath}`);
+            }
+        };
+        for (const layer of tuiLayers)
+            fixTuiFile(layer, levelDirOf(layer));
+        // Ensure the registration level carries its mirror (independent of the
+        // correction pass above - an empty plugin array still needs the entry).
+        const targetIndices = existsSync(target) ? ownIndices(target) : [];
+        if (targetIndices.length === 0) {
+            const data = readJsonc(target);
+            const plugin = Array.isArray(data["plugin"]) ? data["plugin"] : [];
+            plugin.push(wanted);
+            data["plugin"] = plugin;
+            if (!atomicWrite(target, stringify(data, null, 2) + "\n", stateDir)) {
+                return { status: "failed", error: `failed to write ${target}` };
+            }
+            wired = true;
+        }
+        if (wired)
+            return { status: "wired", spec: wanted, target };
+        if (corrected)
+            return { status: "corrected", spec: wanted, target };
+        return { status: "already-wired", spec: wanted };
+    }
+    catch (error) {
+        return { status: "failed", error: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Dual-target server entry.
+ *
+ * - OpenCode v1 resolves `exports["./server"]`, reads `mod.default`, and
+ *   invokes the `server` factory (excess keys are never validated).
+ * - OpenCode v2 imports the same module, validates `mod.default` as
+ *   `{ id, setup }`, and ignores the legacy `server` key - so one default
+ *   export satisfies both loaders.
+ */
+declare const _default: {
+    id: string;
+    server: import("@opencode-ai/plugin").Plugin;
+    setup: import("./v2-types.js").V2ServerSetup;
+};
+export default _default;

package/dist/server.js

@@ -0,0 +1,16 @@
+import { plugin } from "./index.js";
+import { createV2ServerSetup } from "./v2-server.js";
+/**
+ * Dual-target server entry.
+ *
+ * - OpenCode v1 resolves `exports["./server"]`, reads `mod.default`, and
+ *   invokes the `server` factory (excess keys are never validated).
+ * - OpenCode v2 imports the same module, validates `mod.default` as
+ *   `{ id, setup }`, and ignores the legacy `server` key - so one default
+ *   export satisfies both loaders.
+ */
+export default {
+    id: "subagent-explorer",
+    server: plugin,
+    setup: createV2ServerSetup(),
+};