opencode-subagent-magazine 1.1.0

package/dist/index.js

@@ -0,0 +1,1128 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "@opentui/solid/jsx-runtime";
+import { createMemo, createSignal, createEffect, onMount, onCleanup, untrack, Show, For, } from "solid-js";
+import { PLUGIN_VERSION } from "./_version";
+/** OpenCode built-in tool names that spawn sub-agents or delegate tasks. */
+const SUBAGENT_TOOLS = new Set(["task", "delegate", "call_omo_agent"]);
+// ===================================================================
+// i18n
+// ===================================================================
+const I18N = {
+    zh: {
+        "panel.title": "子代理",
+        "status.none": "暂无子代理",
+        "agent.label": "代理",
+        "time.label": "耗时",
+        "tokens.label": "上下文",
+        "error.label": "错误",
+        "model.label": "模型",
+        "todo.label": "进度",
+        "open.label": "进入会话",
+        "cost.label": "费用",
+        "scroll.more": "更多",
+        "scroll.top": "回顶",
+    },
+    en: {
+        "panel.title": "SubAgent",
+        "status.none": "No sub-agents yet",
+        "agent.label": "agent",
+        "time.label": "time",
+        "tokens.label": "tokens",
+        "error.label": "error",
+        "model.label": "model",
+        "todo.label": "todo",
+        "open.label": "Open session",
+        "cost.label": "cost",
+        "scroll.more": "more",
+        "scroll.top": "Top",
+    },
+};
+function detectLang() {
+    const env = process?.env?.OPENCODE_LANG ?? process?.env?.LANG ?? "";
+    if (env.startsWith("zh"))
+        return "zh";
+    return "en";
+}
+// ===================================================================
+// Helpers — visual width
+// ===================================================================
+function charColumns(c) {
+    const code = c.codePointAt(0) ?? 0;
+    if (code < 0x20)
+        return 0;
+    if (code < 0x7f)
+        return 1;
+    if (code < 0xa0)
+        return 0;
+    if ((code >= 0x1100 && code <= 0x115f) ||
+        (code >= 0x2e80 && code <= 0xa4cf) ||
+        (code >= 0xac00 && code <= 0xd7a3) ||
+        (code >= 0xf900 && code <= 0xfaff) ||
+        (code >= 0xfe10 && code <= 0xfe6f) ||
+        (code >= 0xff01 && code <= 0xff60) ||
+        (code >= 0xffe0 && code <= 0xffe6) ||
+        (code >= 0x1f300 && code <= 0x1f64f) ||
+        (code >= 0x20000 && code <= 0x3fffd))
+        return 2;
+    return 1;
+}
+function visualWidth(s) {
+    let w = 0;
+    for (const c of s)
+        w += charColumns(c);
+    return w;
+}
+function truncate(text, maxCols) {
+    if (visualWidth(text) <= maxCols)
+        return text;
+    let cols = 0;
+    let i = 0;
+    for (const c of text) {
+        const w = charColumns(c);
+        if (cols + w > maxCols - 1)
+            break;
+        cols += w;
+        i += c.length;
+    }
+    return text.slice(0, i) + "\u2026";
+}
+function fmtDurationShort(ms, running) {
+    if (running && ms < 2000)
+        return "";
+    if (ms < 1000)
+        return (ms / 1000).toFixed(2) + "s";
+    if (ms < 60000)
+        return (ms / 1000).toFixed(2) + "s";
+    const m = Math.floor(ms / 60000);
+    const s = Math.round((ms % 60000) / 1000);
+    return `${m}m${s}s`;
+}
+function fmtTokens(n) {
+    if (n < 1000)
+        return `${n}`;
+    if (n < 1000000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return `${(n / 1000000).toFixed(1)}M`;
+}
+// ===================================================================
+// Color helpers — Morandi palette
+// ===================================================================
+function rgb(raw) {
+    if (typeof raw === "string" && raw.startsWith("#")) {
+        const h = raw.slice(1);
+        return {
+            r: parseInt(h.slice(0, 2), 16),
+            g: parseInt(h.slice(2, 4), 16),
+            b: parseInt(h.slice(4, 6), 16),
+        };
+    }
+    if (raw && typeof raw === "object") {
+        const o = raw;
+        if (typeof o.r === "number" && typeof o.g === "number" && typeof o.b === "number") {
+            const scale = o.r > 1 || o.g > 1 || o.b > 1 ? 1 : 255;
+            return { r: Math.round(o.r * scale), g: Math.round(o.g * scale), b: Math.round(o.b * scale) };
+        }
+    }
+    return null;
+}
+function saturation(r, g, b) {
+    const max = Math.max(r, g, b) / 255;
+    const min = Math.min(r, g, b) / 255;
+    const delta = max - min;
+    if (delta === 0)
+        return 0;
+    const L = (max + min) / 2;
+    return L <= 0.5 ? delta / (max + min) : delta / (2 - max - min);
+}
+function desaturateTo(raw, maxSat, fallback) {
+    const c = rgb(raw);
+    if (!c)
+        return fallback;
+    const sat = saturation(c.r, c.g, c.b);
+    if (sat <= maxSat) {
+        return "#" + [c.r, c.g, c.b].map((v) => v.toString(16).padStart(2, "0")).join("");
+    }
+    const luma = c.r * 0.299 + c.g * 0.587 + c.b * 0.114;
+    let lo = 0, hi = 1;
+    for (let i = 0; i < 12; i++) {
+        const mid = (lo + hi) / 2;
+        const nr = Math.round(c.r + (luma - c.r) * mid);
+        const ng = Math.round(c.g + (luma - c.g) * mid);
+        const nb = Math.round(c.b + (luma - c.b) * mid);
+        if (saturation(nr, ng, nb) > maxSat)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    const nr = Math.round(c.r + (luma - c.r) * hi);
+    const ng = Math.round(c.g + (luma - c.g) * hi);
+    const nb = Math.round(c.b + (luma - c.b) * hi);
+    return "#" + [nr, ng, nb].map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join("");
+}
+function dimColor(hex, factor = 0.5) {
+    const c = rgb(hex);
+    if (!c)
+        return hex;
+    const r = Math.round(c.r * factor);
+    const g = Math.round(c.g * factor);
+    const b = Math.round(c.b * factor);
+    return "#" + [r, g, b].map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join("");
+}
+const FALLBACK = {
+    primary: "#8B9DAF", text: "#C5C5BB", muted: "#7A7A72",
+    success: "#9CAF8B", warning: "#C5B88D", error: "#B08A8A", border: "#6B6B63",
+};
+const MAX_SAT = 0.28;
+/** Entry line left prefix: icon + space + status dot + space */
+const LEFT_PAD = 4;
+/** Detail row indent: two spaces */
+const INDENT = 2;
+function safeErrorMsg(err) {
+    if (!err)
+        return "";
+    if (typeof err === "string")
+        return err;
+    if (typeof err === "object")
+        return String(err.message || err.code || "");
+    return "";
+}
+// ===================================================================
+// Sidebar component
+// ===================================================================
+function SubAgentPanel(props) {
+    const t = (key) => I18N[props.lang()][key] ?? key;
+    // ── session data (single-key, true deletion on cleanup) ──
+    const SESSION_DATA_KEY = `${KV_PREFIX}.session_data`;
+    const TTL_MS = 3 * 24 * 60 * 60 * 1000;
+    const loadSessionData = () => {
+        try {
+            const raw = props.api.kv.get(SESSION_DATA_KEY, "{}");
+            return JSON.parse(String(raw));
+        }
+        catch {
+            return {};
+        }
+    };
+    const saveSessionData = (data) => {
+        try {
+            props.api.kv.set(SESSION_DATA_KEY, JSON.stringify(data));
+        }
+        catch { }
+    };
+    const loadEntries = (sid) => {
+        const m = new Map();
+        try {
+            const rec = loadSessionData()[sid];
+            if (rec?.entries) {
+                for (const e of rec.entries)
+                    m.set(e.id, e);
+            }
+        }
+        catch { }
+        return m;
+    };
+    let persistTimer;
+    const persistEntries = (sid, entries) => {
+        clearTimeout(persistTimer);
+        persistTimer = setTimeout(() => {
+            try {
+                const data = loadSessionData();
+                data[sid] = { ...data[sid], ts: Date.now(), entries: [...entries.values()] };
+                saveSessionData(data);
+            }
+            catch { }
+        }, 200);
+    };
+    const persistScroll = (sid, scroll) => {
+        try {
+            const data = loadSessionData();
+            data[sid] = { ...data[sid], ts: Date.now(), scroll };
+            saveSessionData(data);
+        }
+        catch { }
+    };
+    const persistExpanded = (sid, expanded) => {
+        try {
+            const data = loadSessionData();
+            data[sid] = { ...data[sid], ts: Date.now(), expanded };
+            saveSessionData(data);
+        }
+        catch { }
+    };
+    const cleanupOldSessions = () => {
+        try {
+            const data = loadSessionData();
+            const cutoff = Date.now() - TTL_MS;
+            let changed = false;
+            for (const sid of Object.keys(data)) {
+                if (data[sid].ts < cutoff) {
+                    delete data[sid];
+                    changed = true;
+                }
+            }
+            if (changed)
+                saveSessionData(data);
+        }
+        catch { }
+    };
+    cleanupOldSessions();
+    const [entryMap, setEntryMapRaw] = createSignal(loadEntries(props.sessionId));
+    // Wrapped setter — also persists to kv on every mutation
+    const setEntryMap = (arg) => {
+        setEntryMapRaw((prev) => {
+            const next = typeof arg === "function" ? arg(prev) : arg;
+            persistEntries(props.sessionId, next);
+            return next;
+        });
+    };
+    const [panelWidth, setPanelWidth] = createSignal(28);
+    const [open, setOpen] = createSignal((() => { try {
+        return props.api.kv.get(`${KV_PREFIX}.open`, true);
+    }
+    catch {
+        return true;
+    } })());
+    const [expanded, setExpanded] = createSignal((() => { try {
+        return loadSessionData()[props.sessionId]?.expanded || undefined;
+    }
+    catch {
+        return undefined;
+    } })());
+    const [hoveredOpen, setHoveredOpen] = createSignal(undefined);
+    const [hoveredTop, setHoveredTop] = createSignal(false);
+    const [scrollOffset, setScrollOffset] = createSignal((() => { try {
+        return loadSessionData()[props.sessionId]?.scroll ?? 0;
+    }
+    catch {
+        return 0;
+    } })());
+    const [now, setNow] = createSignal(Date.now());
+    const [renderTick, setRenderTick] = createSignal(0);
+    let boxEl;
+    let disposed = false;
+    /** Total context tokens for a sub-agent session.
+     *  Matches opencode-visual-cache's "总计": last assistant message's input + cache.read. */
+    const readSessionTokens = (sid) => {
+        if (!sid)
+            return undefined;
+        try {
+            const msgs = props.api.state.session.messages(sid);
+            if (msgs) {
+                for (let i = msgs.length - 1; i >= 0; i--) {
+                    const m = msgs[i];
+                    if (m.role !== "assistant")
+                        continue;
+                    const t = m.tokens;
+                    if (!t)
+                        continue;
+                    const cache = t.cache;
+                    const ctx = (Number(t.input) || 0) + (cache?.read ?? 0);
+                    if (ctx > 0)
+                        return ctx;
+                }
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** Sum USD cost from a session's messages.
+     *  Prefers the database-level aggregate (`session.cost`) which is not affected
+     *  by the sync layer's `limit: 100` message window.  Falls back to message
+     *  traversal when the aggregate is unavailable (older SDK versions). */
+    const readSessionCost = (sid) => {
+        if (!sid)
+            return undefined;
+        try {
+            const session = props.api.state.session.get(sid);
+            if (session?.cost != null && session.cost > 0)
+                return session.cost;
+            const msgs = props.api.state.session.messages(sid);
+            if (!msgs)
+                return undefined;
+            let total = 0;
+            for (const m of msgs) {
+                if (m.role === "assistant" && typeof m.cost === "number")
+                    total += m.cost;
+            }
+            return total > 0 ? total : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** Last assistant message's modelID for a sub-agent session. */
+    const readSessionModel = (sid) => {
+        if (!sid)
+            return undefined;
+        try {
+            const msgs = props.api.state.session.messages(sid);
+            if (msgs) {
+                for (let i = msgs.length - 1; i >= 0; i--) {
+                    const m = msgs[i];
+                    if (m.role === "assistant" && m.modelID)
+                        return String(m.modelID);
+                }
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** Todo completion stats for a sub-agent session.
+     *  `done` counts completed + cancelled items. */
+    const readSessionTodo = (sid) => {
+        if (!sid)
+            return undefined;
+        try {
+            const todos = props.api.state.session.todo(sid);
+            if (!todos || todos.length === 0)
+                return undefined;
+            let done = 0;
+            for (const t of todos) {
+                if (t.status === "completed" || t.status === "cancelled")
+                    done++;
+            }
+            return { total: todos.length, done };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    // ── upsert ──
+    const upsertEntry = (partial) => {
+        setEntryMap((prev) => {
+            const existing = prev.get(partial.id);
+            const next = new Map(prev);
+            const nowTs = Date.now();
+            const e = partial.status;
+            const ended = e === "done" || e === "error";
+            next.set(partial.id, {
+                ...(existing ?? { startedAt: nowTs }),
+                ...partial,
+                startedAt: existing?.startedAt || partial.startedAt || nowTs,
+                endedAt: ended ? (existing?.endedAt || nowTs) : undefined,
+            });
+            return next;
+        });
+    };
+    // ── event handlers ──
+    const handlePartUpdated = (event) => {
+        const e = event;
+        const props_ = e.properties;
+        const part = props_?.part;
+        if (!part)
+            return;
+        // SubtaskPart
+        if (part.type === "subtask") {
+            const agent = String(part.agent ?? "?");
+            const prompt = String(part.prompt ?? "");
+            const desc = String(part.description ?? "");
+            const title = desc || truncate(prompt.replace(/\n/g, " ").replace(/\s+/g, " ").trim(), 40);
+            const id = `sub:${String(part.id ?? crypto.randomUUID())}`;
+            const subSid = part.sessionID !== undefined ? String(part.sessionID) : undefined;
+            const partModel = part.model;
+            const modelId = partModel?.modelID ? String(partModel.modelID) : undefined;
+            upsertEntry({ id, title, agent, prompt, sessionId: subSid, status: "running", model: modelId });
+        }
+        // ToolPart
+        if (part.type === "tool") {
+            const tool = String(part.tool ?? "");
+            if (!SUBAGENT_TOOLS.has(tool))
+                return;
+            const st = part.state;
+            const rawStatus = String(st?.status ?? "");
+            // Only create entries for tool calls that actually entered execution.
+            // "pending" / empty → state unknown yet, wait for next event
+            if (rawStatus === "pending" || rawStatus === "")
+                return;
+            // "error" → tool call failed, sub-agent never spawned.
+            // Only update an existing entry (e.g. previously running → now error),
+            // never create a new one.
+            if (rawStatus === "error") {
+                const id = `tool:${String(part.id ?? "")}`;
+                if (!part.id)
+                    return;
+                const existing = entryMap().get(id);
+                if (existing) {
+                    upsertEntry({ id, title: existing.title, agent: existing.agent, prompt: existing.prompt, status: "error" });
+                }
+                return;
+            }
+            // rawStatus is "running" or "completed" — tool entered execution, track it.
+            const input = st?.input;
+            let status = "running";
+            if (rawStatus === "completed")
+                status = "done";
+            // Background tasks: tool completion ≠ agent completion — keep running until session.idle
+            // Only keep running if state metadata confirms a child session was spawned;
+            // otherwise (failed spawn, invalid agent) mark as done so the entry isn't stuck forever.
+            if (input?.run_in_background === true && status === "done") {
+                const stMetaCheck = st?.metadata;
+                const hasChild = stMetaCheck?.session_id !== undefined || stMetaCheck?.sessionId !== undefined;
+                if (hasChild)
+                    status = "running";
+            }
+            const agent = String(part.subagent_type ?? input?.subagent_type ?? input?.category ?? tool);
+            const prompt = String(input?.prompt ?? part.description ?? "");
+            const desc = input?.description !== undefined ? String(input.description) : "";
+            const title = desc || truncate(prompt.replace(/\n/g, " ").replace(/\s+/g, " ").trim(), 40);
+            const id = `tool:${String(part.id ?? crypto.randomUUID())}`;
+            // Child session ID lives in state-level metadata (ToolStateCompleted.metadata),
+            // injected by the tool executor.  ToolPart.sessionID is the parent session.
+            const stMeta = st?.metadata;
+            const subSid = stMeta?.session_id !== undefined ? String(stMeta.session_id)
+                : stMeta?.sessionId !== undefined ? String(stMeta.sessionId)
+                    : undefined;
+            upsertEntry({ id, title, agent, prompt, sessionId: subSid, status });
+        }
+    };
+    const handleSessionEnd = (event, status) => {
+        const e = event;
+        const props_ = e.properties;
+        const sid = String(props_?.sessionID ?? "");
+        if (!sid)
+            return;
+        const sessionTokens = readSessionTokens(sid);
+        const sessionCost = readSessionCost(sid);
+        const sessionModel = readSessionModel(sid);
+        const sessionTodo = readSessionTodo(sid);
+        let sessionAgent;
+        let errorMsg;
+        try {
+            const s = props.api.state.session.get(sid);
+            sessionAgent = s?.agent;
+            if (status === "error") {
+                const evtErr = props_?.error;
+                errorMsg = safeErrorMsg(evtErr) || safeErrorMsg(props_?.message);
+                if (!errorMsg) {
+                    const msgs = props.api.state.session.messages(sid);
+                    if (msgs) {
+                        for (let i = msgs.length - 1; i >= 0; i--) {
+                            const m = msgs[i];
+                            if (m.role === "assistant" && m.error) {
+                                errorMsg = safeErrorMsg(m.error);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch { }
+        setEntryMap((prev) => {
+            let changed = false;
+            const next = new Map(prev);
+            for (const [id, entry] of next) {
+                if (entry.sessionId !== sid)
+                    continue;
+                if (entry.status !== "running" && entry.status !== "done")
+                    continue;
+                // Skip parent session idle — subagent entries belong to child sessions only
+                if (sid === props.sessionId)
+                    continue;
+                // For "done" entries (sync tasks completed before session.idle), only backfill tokens/cost
+                const alreadySettled = entry.status !== "running";
+                next.set(id, {
+                    ...entry,
+                    ...(alreadySettled ? {} : { status, endedAt: Date.now() }),
+                    tokens: entry.tokens ?? sessionTokens,
+                    cost: entry.cost ?? sessionCost,
+                    model: entry.model ?? sessionModel,
+                    todoTotal: entry.todoTotal ?? sessionTodo?.total,
+                    todoDone: entry.todoDone ?? sessionTodo?.done,
+                    error: errorMsg || entry.error,
+                });
+                changed = true;
+            }
+            if (!changed && sessionAgent) {
+                const nowTs = Date.now();
+                const normalize = (s) => s.toLowerCase().replace(/[^a-z0-9-]/g, "");
+                const saNorm = normalize(sessionAgent);
+                let best = null;
+                // Phase 1: try matching by agent name（agent 名有交集）
+                for (const [id, entry] of next) {
+                    if (entry.status !== "running")
+                        continue;
+                    const eaNorm = normalize(entry.agent);
+                    if (!eaNorm || !saNorm)
+                        continue;
+                    if (!eaNorm.includes(saNorm) && !saNorm.includes(eaNorm))
+                        continue;
+                    const gap = nowTs - (entry.startedAt || 0);
+                    if (!best || gap > best.gap)
+                        best = { id, gap };
+                }
+                // Phase 2: if agent name has no overlap (e.g. category calls: agent="deep" vs sessionAgent="Sisyphus-Junior"),
+                // fall back to time proximity for entries that have no sessionId yet
+                if (!best) {
+                    for (const [id, entry] of next) {
+                        if (entry.status !== "running")
+                            continue;
+                        if (entry.sessionId)
+                            continue;
+                        const gap = nowTs - (entry.startedAt || 0);
+                        if (!best || gap > best.gap)
+                            best = { id, gap };
+                    }
+                }
+                if (best) {
+                    const entry = next.get(best.id);
+                    next.set(best.id, {
+                        ...entry, status, endedAt: nowTs,
+                        tokens: sessionTokens || entry.tokens,
+                        cost: sessionCost || entry.cost,
+                        sessionId: sid,
+                        error: errorMsg || entry.error,
+                    });
+                    changed = true;
+                }
+            }
+            return changed ? next : prev;
+        });
+        // Delayed backfill: re-read data after state sync catches up, to capture the final
+        // token/cost values that may not have been available when session.idle fired.
+        setTimeout(() => {
+            if (disposed)
+                return;
+            const finalTokens = readSessionTokens(sid);
+            const finalCost = readSessionCost(sid);
+            const finalModel = readSessionModel(sid);
+            const finalTodo = readSessionTodo(sid);
+            setEntryMap((prev) => {
+                let changed = false;
+                const next = new Map(prev);
+                for (const [id, entry] of next) {
+                    if (entry.sessionId !== sid)
+                        continue;
+                    const t = finalTokens ?? entry.tokens;
+                    const c = finalCost ?? entry.cost;
+                    const m = finalModel ?? entry.model;
+                    const tt = finalTodo?.total ?? entry.todoTotal;
+                    const td = finalTodo?.done ?? entry.todoDone;
+                    if (t !== entry.tokens || c !== entry.cost || m !== entry.model ||
+                        tt !== entry.todoTotal || td !== entry.todoDone) {
+                        next.set(id, { ...entry, tokens: t, cost: c, model: m, todoTotal: tt, todoDone: td });
+                        changed = true;
+                    }
+                }
+                return changed ? next : prev;
+            });
+            bump();
+        }, 150);
+    };
+    // ── bumpRenderTick: force re-render (visual-cache pattern) ──
+    const bump = () => setRenderTick((v) => v + 1);
+    onMount(() => {
+        // Fast clock for smooth time display, separate from token polling
+        const clock = setInterval(() => { setNow(Date.now()); bump(); }, 100);
+        // Token poll — runs every 500ms for running entries
+        const tokenTimer = setInterval(() => {
+            untrack(() => {
+                setEntryMapRaw((prev) => {
+                    let changed = false;
+                    const next = new Map(prev);
+                    for (const [id, entry] of next) {
+                        if (entry.status === "running" && entry.sessionId) {
+                            // Only read from child sessions, never the parent
+                            let isChild = false;
+                            try {
+                                const s = props.api.state.session.get(entry.sessionId);
+                                isChild = s?.parentID === props.sessionId;
+                            }
+                            catch { }
+                            if (!isChild)
+                                continue;
+                            const total = readSessionTokens(entry.sessionId);
+                            const todo = readSessionTodo(entry.sessionId);
+                            const model = entry.model ?? readSessionModel(entry.sessionId);
+                            const nextEntry = { ...entry };
+                            if (total !== undefined && total !== entry.tokens) {
+                                nextEntry.tokens = total;
+                                changed = true;
+                            }
+                            if (todo !== undefined) {
+                                if (todo.total !== entry.todoTotal || todo.done !== entry.todoDone) {
+                                    nextEntry.todoTotal = todo.total;
+                                    nextEntry.todoDone = todo.done;
+                                    changed = true;
+                                }
+                            }
+                            if (model && !entry.model) {
+                                nextEntry.model = model;
+                                changed = true;
+                            }
+                            if (changed)
+                                next.set(id, nextEntry);
+                        }
+                    }
+                    return changed ? next : prev;
+                });
+            });
+            bump();
+        }, 500);
+        bump();
+        const unsubPart = props.api.event.on("message.part.updated", (e) => {
+            handlePartUpdated(e);
+            bump();
+        });
+        const unsubMsg = props.api.event.on("message.updated", () => bump());
+        const unsubIdle = props.api.event.on("session.idle", (e) => {
+            handleSessionEnd(e, "done");
+            bump();
+        });
+        const unsubError = props.api.event.on("session.error", (e) => {
+            handleSessionEnd(e, "error");
+            bump();
+        });
+        onCleanup(() => {
+            disposed = true;
+            clearInterval(clock);
+            clearInterval(tokenTimer);
+            unsubPart();
+            unsubMsg();
+            unsubIdle();
+            unsubError();
+        });
+    });
+    // ── session‑switch & initial‑load scan ──
+    // On session change: load from kv (entries survive component unmount), then scan+merge.
+    // On same session: only scan+merge (keep event‑driven running entries).
+    let lastSid = props.sessionId;
+    createEffect(() => {
+        const sid = props.sessionId;
+        const switched = sid !== lastSid;
+        lastSid = sid;
+        const t = setTimeout(() => {
+            untrack(() => {
+                if (switched) {
+                    const saved = loadSessionData()[sid]?.scroll ?? 0;
+                    setScrollOffset(saved);
+                }
+                // scan uses setEntryMapRaw — ephemeral data, not persisted to kv.
+                // Only event-driven changes (handlePartUpdated, handleSessionEnd) persist.
+                setEntryMapRaw((prev) => {
+                    const next = switched ? loadEntries(sid) : new Map(prev);
+                    try {
+                        const msgs = props.api.state.session.messages(sid);
+                        if (msgs && msgs.length) {
+                            for (const msg of msgs) {
+                                const parts = props.api.state.part(msg.id) ?? [];
+                                for (const partRaw of parts) {
+                                    const part = partRaw;
+                                    // Subtask entries are purely event-driven — never created by scan.
+                                    // (SubtaskPart exists from spawn, not completion, so we cannot infer status.)
+                                    if (part.type === "tool") {
+                                        const tool = String(part.tool ?? "");
+                                        if (!SUBAGENT_TOOLS.has(tool))
+                                            continue;
+                                        const id = `tool:${String(part.id ?? "")}`;
+                                        if (!part.id)
+                                            continue;
+                                        const st = part.state;
+                                        const rawStatus = String(st?.status ?? "");
+                                        const exists = next.get(id);
+                                        // Only create entries for tool calls that entered execution.
+                                        // "pending" / empty: skip new entries; allow heuristics for existing ones below.
+                                        if ((rawStatus === "pending" || rawStatus === "") && !exists)
+                                            continue;
+                                        // "error": only update existing, never create a new entry
+                                        if (rawStatus === "error") {
+                                            if (exists && exists.status === "running") {
+                                                next.set(id, { ...exists, status: "error", endedAt: Date.now() });
+                                            }
+                                            continue;
+                                        }
+                                        let status = "running";
+                                        if (rawStatus === "completed")
+                                            status = "done";
+                                        // Background tasks: tool completion ≠ agent completion — keep running until session.idle
+                                        // Only keep running if state metadata confirms a child session was spawned.
+                                        if (st?.input?.run_in_background === true && status === "done") {
+                                            const scanStMeta = st?.metadata;
+                                            const scanHasChild = scanStMeta?.session_id !== undefined || scanStMeta?.sessionId !== undefined;
+                                            if (scanHasChild)
+                                                status = "running";
+                                        }
+                                        // Already settled → skip
+                                        if (exists && exists.status !== "running")
+                                            continue;
+                                        // Running entry with no explicit status improvement from part:
+                                        // try message-level heuristics first, then time-based fallback.
+                                        if (exists && status === "running") {
+                                            if (!rawStatus) {
+                                                const msgTokens = msg?.tokens;
+                                                if (msgTokens && (Number(msgTokens.input) > 0 || Number(msgTokens.output) > 0)) {
+                                                    status = "done"; // LLM returned tokens → agent completed
+                                                }
+                                                else if (Date.now() - exists.startedAt > 30 * 60 * 1000) {
+                                                    status = "done"; // >30 min idle → assume completed
+                                                }
+                                                else {
+                                                    continue;
+                                                }
+                                            }
+                                            else {
+                                                continue;
+                                            }
+                                        }
+                                        // If already tracked as running but tool state says completed/error → update
+                                        // If not tracked → add fresh
+                                        const input = st?.input;
+                                        const agent = String(part.subagent_type ?? input?.subagent_type ?? tool);
+                                        const prompt = String(input?.prompt ?? part.description ?? "");
+                                        const desc = input?.description !== undefined ? String(input.description) : "";
+                                        const title = desc || truncate(prompt.replace(/\n/g, " ").trim(), 40);
+                                        let tokens;
+                                        const scanStMeta2 = st?.metadata;
+                                        const scanSubSid = scanStMeta2?.session_id !== undefined ? String(scanStMeta2.session_id)
+                                            : scanStMeta2?.sessionId !== undefined ? String(scanStMeta2.sessionId)
+                                                : undefined;
+                                        if (scanSubSid)
+                                            tokens = readSessionTokens(scanSubSid);
+                                        const ended = status === "done"; // "error" handled above, never reaches here
+                                        next.set(id, {
+                                            id, title, agent, prompt,
+                                            // Preserve existing values (from handleSessionEnd / KV) — scan must not overwrite
+                                            tokens: exists?.tokens ?? tokens,
+                                            sessionId: exists?.sessionId ?? scanSubSid,
+                                            status,
+                                            startedAt: exists?.startedAt || Date.now(),
+                                            endedAt: ended ? (exists?.endedAt || Date.now()) : undefined,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch { }
+                    return next;
+                });
+                // Reconcile: check running entries against live child session status.
+                // Covers session.idle events missed while user was inside a child session.
+                setEntryMapRaw((prev) => {
+                    let changed = false;
+                    const next = new Map(prev);
+                    for (const [id, entry] of next) {
+                        if (entry.status !== "running" || !entry.sessionId)
+                            continue;
+                        try {
+                            const st = props.api.state.session.status(entry.sessionId);
+                            if (!st || st.type !== "idle")
+                                continue;
+                            const tokens = readSessionTokens(entry.sessionId);
+                            const cost = readSessionCost(entry.sessionId);
+                            next.set(id, {
+                                ...entry, status: "done", endedAt: Date.now(),
+                                tokens: tokens ?? entry.tokens,
+                                cost: cost ?? entry.cost,
+                            });
+                            changed = true;
+                        }
+                        catch { }
+                    }
+                    return changed ? next : prev;
+                });
+                bump();
+            });
+        }, 150);
+        onCleanup(() => clearTimeout(t));
+    });
+    // ── palette ──
+    const pal = createMemo(() => {
+        const th = props.theme;
+        const sat = (k, fb) => desaturateTo(th[k], MAX_SAT, fb);
+        return {
+            primary: sat("primary", FALLBACK.primary),
+            text: sat("text", FALLBACK.text),
+            muted: sat("textMuted", FALLBACK.muted),
+            success: sat("success", FALLBACK.success),
+            warning: sat("warning", FALLBACK.warning),
+            error: sat("error", FALLBACK.error),
+            border: sat("border", FALLBACK.border),
+        };
+    });
+    // ── derived signals ──
+    // Stable list — only changes when entryMap changes
+    const entryList = createMemo(() => {
+        return [...entryMap().values()].sort((a, b) => b.startedAt - a.startedAt);
+    });
+    const max = props.maxEntries;
+    const clampedOffset = createMemo(() => {
+        const total = entryList().length;
+        const m = max();
+        if (total <= m)
+            return 0;
+        return Math.min(scrollOffset(), total - m);
+    });
+    const visibleList = createMemo(() => entryList().slice(clampedOffset(), clampedOffset() + max()));
+    const hiddenAbove = createMemo(() => clampedOffset());
+    const hiddenBelow = createMemo(() => Math.max(0, entryList().length - clampedOffset() - max()));
+    const entries = createMemo(() => {
+        const nowVal = now();
+        return entryList().map((e) => ({
+            ...e,
+            elapsed: (e.endedAt ?? nowVal) - e.startedAt,
+        }));
+    });
+    const doneCount = createMemo(() => entryList().filter((e) => e.status === "done").length);
+    const runningCount = createMemo(() => entryList().filter((e) => e.status === "running").length);
+    const errCount = createMemo(() => entryList().filter((e) => e.status === "error").length);
+    const anyEntry = () => entryList().length > 0;
+    const totalTokens = createMemo(() => {
+        let sum = 0;
+        for (const e of entryList()) {
+            if (e.tokens)
+                sum += e.tokens;
+        }
+        return sum;
+    });
+    const totalCost = createMemo(() => {
+        let sum = 0;
+        for (const e of entryList()) {
+            if (e.cost)
+                sum += e.cost;
+        }
+        return sum;
+    });
+    const toggleExpand = (id) => {
+        setExpanded((prev) => {
+            const next = prev === id ? undefined : id;
+            try {
+                persistExpanded(props.sessionId, next ?? "");
+            }
+            catch { }
+            return next;
+        });
+    };
+    const sep = () => "\u2500".repeat(Math.max(1, panelWidth()));
+    // ── expanded detail right-align ──
+    const expandedMaxLabelW = createMemo(() => {
+        const labels = [
+            t("agent.label"), t("time.label"), t("tokens.label"),
+            t("error.label"), t("cost.label"), t("model.label"), t("todo.label"),
+        ];
+        return Math.max(...labels.map(l => visualWidth(l + ": ")));
+    });
+    const expandedPad = (label) => Math.max(0, expandedMaxLabelW() - visualWidth(label + ": "));
+    const expandedValAvail = () => Math.max(6, panelWidth() - INDENT - expandedMaxLabelW());
+    // ── header parts for colored spans ──
+    const summaryParts = createMemo(() => {
+        if (!anyEntry())
+            return null;
+        const dot = "\u25cf";
+        const cost = totalCost();
+        return {
+            done: `${dot}${doneCount()}`,
+            running: runningCount() > 0 ? `${dot}${runningCount()}` : null,
+            err: errCount() > 0 ? `${dot}${errCount()}` : null,
+            duration: totalTokens() > 0 ? fmtTokens(totalTokens()) : "",
+            cost: cost > 0 ? `$${cost.toFixed(2)}` : "",
+        };
+    });
+    const summaryCols = createMemo(() => {
+        const p = summaryParts();
+        if (!p)
+            return 0;
+        let w = visualWidth(p.done);
+        if (p.running)
+            w += 1 + visualWidth(p.running);
+        if (p.err)
+            w += 1 + visualWidth(p.err);
+        w += p.duration ? 1 + visualWidth(p.duration) : 0;
+        w += p.cost ? 1 + visualWidth(p.cost) : 0;
+        return w;
+    });
+    const versionText = ` v${PLUGIN_VERSION}`;
+    const versionW = visualWidth(versionText);
+    const showVersion = createMemo(() => {
+        if (!open())
+            return false;
+        const icon = "\u25bc";
+        const need = visualWidth(icon) + 1 + visualWidth(t("panel.title")) + versionW + summaryCols();
+        return need <= panelWidth();
+    });
+    const leftCols = createMemo(() => {
+        const icon = open() ? "\u25bc" : "\u25b6";
+        let w = visualWidth(icon) + 1 + visualWidth(t("panel.title"));
+        if (showVersion())
+            w += versionW;
+        return w;
+    });
+    const spacerCols = createMemo(() => {
+        if (!anyEntry())
+            return 0;
+        return Math.max(0, panelWidth() - leftCols() - summaryCols());
+    });
+    const valueCols = (label) => Math.max(4, panelWidth() - INDENT - visualWidth(label + ": "));
+    // ── render ──
+    return (_jsxs("box", { border: false, paddingTop: 0, paddingBottom: 0, paddingLeft: 0, paddingRight: 0, flexDirection: "column", gap: 0, ref: boxEl, onSizeChange: () => {
+            const w = boxEl ? Math.max(20, boxEl.width ?? 0) : 28;
+            setPanelWidth((prev) => (prev === w ? prev : w));
+        }, children: [_jsxs("text", { onMouseUp: () => {
+                    setOpen((o) => {
+                        const n = !o;
+                        try {
+                            props.api.kv.set(`${KV_PREFIX}.open`, n);
+                        }
+                        catch { }
+                        return n;
+                    });
+                    bump();
+                }, children: [_jsx("span", { style: { fg: pal().muted }, children: renderTick() >= 0 && open() ? "\u25bc " : "\u25b6 " }), _jsx("span", { style: { fg: pal().primary }, children: t("panel.title") }), _jsx(Show, { when: showVersion(), children: _jsx("span", { style: { fg: dimColor(pal().muted, 0.75) }, children: versionText }) }), anyEntry() ? (_jsxs(_Fragment, { children: [_jsx("span", { style: { fg: pal().muted }, children: " ".repeat(spacerCols()) }), _jsx("span", { style: { fg: pal().success }, children: summaryParts().done }), runningCount() > 0 && (_jsxs("span", { style: { fg: pal().warning }, children: [" ", summaryParts().running] })), errCount() > 0 && (_jsxs("span", { style: { fg: pal().error }, children: [" ", summaryParts().err] })), summaryParts().duration ? (_jsxs("span", { style: { fg: pal().muted }, children: [" ", summaryParts().duration] })) : null, summaryParts().cost ? (_jsxs("span", { style: { fg: pal().warning }, children: [" ", summaryParts().cost] })) : null] })) : null] }), _jsxs(Show, { when: open(), children: [_jsx("text", { fg: pal().muted, children: sep() }), _jsx(Show, { when: anyEntry(), fallback: _jsxs("text", { style: { fg: pal().muted }, children: ["  ", "> ", t("status.none"), "  "] }), children: _jsxs("box", { onMouseScroll: (e) => {
+                                const total = entryList().length;
+                                const m = max();
+                                if (total <= m)
+                                    return;
+                                const dir = e.button === 0 ? 1 : -1;
+                                setScrollOffset((prev) => {
+                                    const next = Math.max(0, Math.min(prev + dir, total - m));
+                                    try {
+                                        persistScroll(props.sessionId, next);
+                                    }
+                                    catch { }
+                                    return next;
+                                });
+                            }, children: [_jsx(Show, { when: hiddenAbove() > 0, children: _jsxs("text", { style: { fg: pal().muted }, children: ["  ", "\u2191 ", hiddenAbove(), " ", t("scroll.more")] }) }), _jsx(For, { each: visibleList(), children: (entry) => {
+                                        const isExpanded = () => expanded() === entry.id;
+                                        const isRunning = entry.status === "running";
+                                        const isError = entry.status === "error";
+                                        const elapsed = () => (entry.endedAt ?? now()) - entry.startedAt;
+                                        const statusDot = () => "\u25cf";
+                                        const statusColor = () => {
+                                            if (!isRunning)
+                                                return isError ? pal().error : pal().success;
+                                            const t = (Math.sin(((now() % 2000) / 2000) * Math.PI * 2 - Math.PI / 2) + 1) / 2;
+                                            const a = rgb(pal().muted), b = rgb(pal().warning);
+                                            if (!a || !b)
+                                                return pal().warning;
+                                            const r = Math.round(a.r + (b.r - a.r) * t);
+                                            const g = Math.round(a.g + (b.g - a.g) * t);
+                                            const bl = Math.round(a.b + (b.b - a.b) * t);
+                                            return "#" + [r, g, bl].map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join("");
+                                        };
+                                        const timeColor = () => isRunning ? pal().warning : isError ? pal().error : pal().muted;
+                                        // Entry label: collapsed shows title only, expanded shows title only too
+                                        const tokenText = () => !isExpanded() && entry.tokens !== undefined && entry.tokens > 0
+                                            ? ` ${fmtTokens(entry.tokens)}`
+                                            : "";
+                                        const timeText = () => !isExpanded() && (elapsed() >= 2000 || entry.endedAt !== undefined)
+                                            ? fmtDurationShort(elapsed(), isRunning)
+                                            : "";
+                                        const suffixW = () => {
+                                            let w = 0;
+                                            const t = timeText();
+                                            if (t)
+                                                w += 1 + visualWidth(t);
+                                            const tk = tokenText();
+                                            if (tk)
+                                                w += visualWidth(tk);
+                                            return w;
+                                        };
+                                        const labelAvail = () => Math.max(6, panelWidth() - LEFT_PAD - suffixW());
+                                        const labelText = () => {
+                                            const max = labelAvail();
+                                            const text = entry.title || entry.agent;
+                                            const truncated = truncate(text, max);
+                                            const pad = Math.max(0, max - visualWidth(truncated));
+                                            return truncated + " ".repeat(pad);
+                                        };
+                                        return (_jsxs(_Fragment, { children: [_jsxs("text", { onMouseUp: () => toggleExpand(entry.id), children: [_jsx("span", { style: { fg: pal().muted }, children: isExpanded() ? "\u25bc" : "\u25b6" }), " ", _jsx("span", { style: { fg: statusColor() }, children: statusDot() }), " ", _jsx("span", { style: { fg: pal().text }, children: labelText() }), timeText() ? (_jsxs(_Fragment, { children: [" ", _jsx("span", { style: { fg: timeColor() }, children: timeText() })] })) : null, tokenText() ? (_jsx("span", { style: { fg: pal().muted }, children: tokenText() })) : null] }), _jsxs(Show, { when: isExpanded(), children: [_jsxs("text", { children: ["  ", _jsxs("span", { style: { fg: pal().primary }, children: [t("agent.label"), ": "] }), _jsx("span", { style: { fg: pal().muted }, children: " ".repeat(expandedPad(t("agent.label"))) }), _jsx("span", { style: { fg: pal().muted }, children: entry.agent })] }), _jsx(Show, { when: elapsed() >= 2000 || entry.endedAt !== undefined, children: _jsxs("text", { children: ["  ", _jsxs("span", { style: { fg: pal().primary }, children: [t("time.label"), ": "] }), _jsx("span", { style: { fg: pal().muted }, children: " ".repeat(expandedPad(t("time.label"))) }), _jsx("span", { style: { fg: pal().muted }, children: fmtDurationShort(elapsed(), isRunning) })] }) }), _jsx(Show, { when: entry.tokens !== undefined, children: _jsxs("text", { children: ["  ", _jsxs("span", { style: { fg: pal().primary }, children: [t("tokens.label"), ": "] }), _jsx("span", { style: { fg: pal().muted }, children: " ".repeat(expandedPad(t("tokens.label"))) }), _jsx("span", { style: { fg: pal().muted }, children: fmtTokens(entry.tokens) })] }) }), _jsx(Show, { when: entry.error, children: _jsxs("text", { children: ["  ", _jsxs("span", { style: { fg: pal().error }, children: [t("error.label"), ": "] }), _jsx("span", { style: { fg: pal().muted }, children: " ".repeat(expandedPad(t("error.label"))) }), _jsx("span", { style: { fg: pal().error }, children: truncate(String(entry.error), expandedValAvail()) })] }) }), _jsx(Show, { when: entry.cost !== undefined, children: _jsxs("text", { children: ["  ", _jsxs("span", { style: { fg: pal().primary }, children: [t("cost.label"), ": "] }), _jsx("span", { style: { fg: pal().muted }, children: " ".repeat(expandedPad(t("cost.label"))) }), _jsxs("span", { style: { fg: pal().muted }, children: ["$", entry.cost.toFixed(4)] })] }) }), _jsx(Show, { when: entry.model, children: _jsxs("text", { children: ["  ", _jsxs("span", { style: { fg: pal().primary }, children: [t("model.label"), ": "] }), _jsx("span", { style: { fg: pal().muted }, children: " ".repeat(expandedPad(t("model.label"))) }), _jsx("span", { style: { fg: pal().muted }, children: truncate(entry.model, expandedValAvail()) })] }) }), _jsx(Show, { when: entry.todoTotal !== undefined, children: _jsxs("text", { children: ["  ", _jsxs("span", { style: { fg: pal().primary }, children: [t("todo.label"), ": "] }), _jsx("span", { style: { fg: pal().muted }, children: " ".repeat(expandedPad(t("todo.label"))) }), _jsxs("span", { style: { fg: pal().muted }, children: [entry.todoDone, "/", entry.todoTotal] })] }) }), _jsx(Show, { when: entry.sessionId, children: _jsxs("text", { onMouseOver: () => setHoveredOpen(entry.id), onMouseOut: () => setHoveredOpen(undefined), onMouseUp: () => {
+                                                                    if (entry.sessionId) {
+                                                                        props.api.route.navigate("session", { sessionID: entry.sessionId });
+                                                                    }
+                                                                }, children: ["  ", _jsx("span", { style: { fg: hoveredOpen() === entry.id ? pal().warning : pal().primary }, children: "\u2192 " }), _jsx("span", { style: { fg: hoveredOpen() === entry.id ? pal().warning : pal().primary }, children: t("open.label") })] }) })] })] }));
+                                    } }), _jsx(Show, { when: hiddenBelow() > 0 || scrollOffset() > 0, children: (() => {
+                                        const showMore = hiddenBelow() > 0;
+                                        const showTop = scrollOffset() > 0;
+                                        const left = showMore ? `  \u2193 ${hiddenBelow()} ${t("scroll.more")}` : "  ";
+                                        const right = `\u2191 ${t("scroll.top")}`;
+                                        const pad = showTop ? Math.max(1, panelWidth() - visualWidth(left) - visualWidth(right)) : 0;
+                                        return (_jsxs("box", { flexDirection: "row", children: [_jsx("text", { style: { fg: pal().muted }, children: left }), showTop ? (_jsxs(_Fragment, { children: [_jsx("text", { style: { fg: pal().muted }, children: " ".repeat(pad) }), _jsx("text", { onMouseOver: () => setHoveredTop(true), onMouseOut: () => setHoveredTop(false), onMouseUp: () => { setScrollOffset(0); setHoveredTop(false); }, children: _jsx("span", { style: { fg: hoveredTop() ? pal().warning : pal().muted }, children: right }) })] })) : null] }));
+                                    })() })] }) })] })] }));
+}
+function createSidebarSlot(api, sig) {
+    return {
+        order: 60,
+        slots: {
+            sidebar_content(ctx, input) {
+                sig.sessionId = input.session_id;
+                return (_jsx(SubAgentPanel, { theme: ctx.theme.current, api: api, lang: sig.lang, maxEntries: sig.maxEntries, sessionId: input.session_id }));
+            },
+        },
+    };
+}
+const KV_PREFIX = "subagent_magazine";
+const tui = async (api) => {
+    // ── language ──
+    const stored = String(api.kv.get(`${KV_PREFIX}.lang`, ""));
+    const initialLang = stored === "zh" || stored === "en" ? stored : detectLang();
+    const [lang, setLang] = createSignal(initialLang);
+    const [maxEntries, setMaxEntries] = createSignal(parseInt(String(api.kv.get(`${KV_PREFIX}.max_entries`, "10")), 10) || 10);
+    const signals = { lang, setLang, maxEntries, setMaxEntries, sessionId: "" };
+    api.slots.register(createSidebarSlot(api, signals));
+    // ── slash command: /subagent-lang ──
+    api.command?.register(() => [
+        {
+            title: "SubAgent Magazine: Language",
+            value: "subagent-lang",
+            description: "Switch display language (中文 / English)",
+            slash: { name: "subagent-lang" },
+            onSelect: (dialog) => {
+                dialog?.replace(() => (_jsx(api.ui.DialogSelect, { title: "Language / \u8BED\u8A00", options: [
+                        { title: "中文", value: "zh" },
+                        { title: "English", value: "en" },
+                    ], onSelect: (opt) => {
+                        const l = opt.value;
+                        setLang(l);
+                        api.kv.set(`${KV_PREFIX}.lang`, l);
+                        api.ui.toast({
+                            message: l === "zh" ? "语言: 中文" : "Language: English",
+                        });
+                        dialog?.clear();
+                    } })));
+            },
+        },
+        {
+            title: "SubAgent Magazine: Max Entries",
+            value: "subagent-max",
+            description: "Set max visible sub-agent entries in sidebar",
+            slash: { name: "subagent-max" },
+            onSelect: (dialog) => {
+                dialog?.replace(() => (_jsx(api.ui.DialogPrompt, { title: "Max Visible Entries", description: () => (_jsx("text", { children: "Number of entries to show in the sidebar (1\u201350)" })), value: String(maxEntries()), onConfirm: (val) => {
+                        const n = Math.max(1, Math.min(50, parseInt(val, 10) || 10));
+                        setMaxEntries(n);
+                        api.kv.set(`${KV_PREFIX}.max_entries`, n);
+                        api.ui.toast({ message: `Max entries: ${n}` });
+                        dialog?.clear();
+                    } })));
+            },
+        },
+        {
+            title: "SubAgent Magazine: Version",
+            value: "subagent-version",
+            description: "Show plugin version",
+            slash: { name: "subagent-version" },
+            onSelect: (dialog) => {
+                api.ui.toast({ message: `opencode-subagent-magazine v${PLUGIN_VERSION}` });
+                dialog?.clear();
+            },
+        },
+        {
+            title: "SubAgent Magazine: Session",
+            value: "subagent-session",
+            description: "Show current session ID",
+            slash: { name: "subagent-session" },
+            onSelect: (dialog) => {
+                api.ui.toast({ message: `Session: ${signals.sessionId}` });
+                dialog?.clear();
+            },
+        },
+    ]);
+};
+const mod = {
+    id: "opencode-subagent-magazine",
+    tui,
+};
+export default mod;