@litfamily/litopencode 1.0.36 → 1.0.37

package/dist/v2/tui.js

@@ -1,26 +1,52 @@
-// LitOpenCode's OpenCode 2 TUI plugin: the mission panel in the session sidebar, the ignition line under
-// the prompt (`🔥 LIT IGNITED · <discipline>`, the OpenCode 2 home of the OpenCode 1 completion mark),
-// and toasts. OpenCode 2 loads it on its own for an active server plugin. The server cannot raise toasts
-// on OpenCode 2, so the ignition toast is inferred here from the lit mark the server writes into the user
-// message metadata. It only reads state. OpenTUI and Solid come from the host at run time; tests pass a
-// stand-in runtime.
+// LitOpenCode's OpenCode 2 TUI plugin: the same HUD OpenCode 1 draws, placed in the slots OpenCode 2
+// publishes (@opencode/plugin SlotMap). The status card sits after the prompt footer, the stage chip and
+// the ignition line (`🔥 LIT IGNITED · <discipline>`, the OpenCode 2 home of the OpenCode 1 completion
+// mark) share prompt.footer.status, the home line is in home.footer and the mission panel in
+// sidebar.content. Toasts cover the gate events, the stage moving, discipline switches, lanes, the
+// ignition and the restart notice, with an opt-in finish alert. OpenCode 2 loads the plugin on its own
+// for an active server plugin. The server cannot raise toasts there, so the ignition toast is inferred
+// from the lit mark the server writes into the user message metadata. It only reads state. OpenTUI and
+// Solid come from the host at run time; tests pass a stand-in runtime.
 import { activationDiscipline } from "../activation-probe.js";
+import { readPackageMetadata } from "../cli/json.js";
 import { micro, supportsMarkGlyphs } from "../lit-mark.js";
-import { buildMissionView, leadingNotice, missionNotices } from "../tui/mission-model.js";
+import { readInstalledVersions, restartVersion } from "../restart-notice.js";
+import { buildMissionView, lastMission, leadingNotice, missionNotices } from "../tui/mission-model.js";
 import { idleMotion, motionTiming, planMotion, sampleMotion } from "../tui/mission-motion.js";
 import { latestLitMarkV2, missionStateFromV2 } from "../tui/mission-source-v2.js";
-import { createLedgerReader, createWorkReader, missionProjectRoot, readLatestResearchRun, readMissionInput } from "../tui/mission-source.js";
-import { missionPanel, paletteFromTheme, panelWidth } from "../tui/mission-text.js";
+import { adhdSuggestDue, createLedgerReader, createWorkReader, earlierWorkWindowMs, hasEarlierWork, messageTimes, missionProjectRoot, readCardInput, readLatestResearchRun, readMissionInput, readThreadSources, wayBackDue } from "../tui/mission-source.js";
+import { chipShimmer, idleChipMotion, planChipMotion } from "../tui/mission-skills.js";
+import { bandCard, readBandOptions, readNotifyOptions, statusCard } from "../tui/mission-band.js";
+import { activeSkillLook, turnGlow, waitingOnYou } from "../tui/mission-looks.js";
+import { rainbowActive, rainbowAllowed, rainbowAt, rainbowShows, rainbowTickMs } from "../tui/mission-rainbow.js";
+import { threadLineCount, threadsOf } from "../tui/mission-threads.js";
+import { chipLine, cellWidth, homeLine, lineWidth, missionPanel, paletteFromTheme, panelWidth } from "../tui/mission-text.js";
+import { v2StageNotices } from "./tui-notices.js";
 const refreshDelayMs = 80;
 const ledgerPollMs = 2000;
 const toastMs = 4000;
 const ignitionToastMs = 6000;
+const liveTickMs = 1000;
+const restartCheckMs = 10 * 60_000;
 const trackedSessionLimit = 4;
+const homeLineWidth = 69;
 // A lit mark older than the moment a session is first drawn is history being loaded, not a new turn.
 const historySlackMs = 2000;
+const defaultWidth = 120;
+// What the footer row holds besides our line: the host's spinner and hint on the left, its token, cost,
+// goal and `ctrl+p commands` figures on the right (measured with a turn running, when they are widest).
+const hostFooterCells = 68;
+const sidebarCells = 42;
+const sidebarMinWidth = 120;
 async function hostRuntime() {
-    const [jsxRuntime, solid] = await Promise.all([import("@opentui/solid/jsx-runtime"), import("solid-js")]);
-    return { jsx: jsxRuntime.jsx, createSignal: solid.createSignal, createEffect: solid.createEffect, createRoot: solid.createRoot };
+    const [jsxRuntime, solid, opentui] = await Promise.all([import("@opentui/solid/jsx-runtime"), import("solid-js"), import("@opentui/solid")]);
+    return {
+        jsx: jsxRuntime.jsx,
+        createSignal: solid.createSignal,
+        createEffect: solid.createEffect,
+        createRoot: solid.createRoot,
+        useTerminalDimensions: opentui.useTerminalDimensions
+    };
 }
 /** OpenCode 2 theme tokens under the names the mission palette reads. */
 export function paletteFromV2Theme(theme, mode) {
@@ -42,23 +68,33 @@ export async function setupLitOpenCodeTui(context, runtime) {
     const ui = runtime ?? await hostRuntime();
     const [settings] = context.storage.store("settings", { initial: { motion: true } });
     const motionEnabled = settings.motion !== false;
+    const band = readBandOptions(context.options);
+    const notify = readNotifyOptions(context.options);
     const directory = context.location?.directory ?? context.data.location.default().directory;
     const root = missionProjectRoot({ directory });
     const readLedger = createLedgerReader();
     const readWork = createWorkReader();
+    const colorAllowed = rainbowAllowed(motionEnabled, process.env.NO_COLOR);
     const sessions = new Map();
     const ignitions = new Map();
     const trackedAt = new Map();
     const tracked = [];
+    const suggested = new Set();
+    const suggestedDays = new Map();
     // Each session's store watcher lives in its own root, so it outlasts the slot render that started it
     // and ends only on eviction or cleanup. After cleanup nothing may arm a timer again.
     const watchers = new Map();
     let disposed = false;
     const [revision, setRevision] = ui.createSignal(0);
     const [clock, setClock] = ui.createSignal(Date.now());
+    // The version this start loaded; an install newer than it shows `restart to <v>` and one toast.
+    const [restartTo, setRestartTo] = ui.createSignal(undefined);
     let frameTimer;
     let refreshTimer;
     let pollTimer;
+    let liveTimer;
+    let bandTimer;
+    let restartTimer;
     const palette = () => paletteFromV2Theme(context.theme, context.themeMode);
     function span(segment) {
         return ui.jsx("span", {
@@ -69,17 +105,43 @@ export async function setupLitOpenCodeTui(context, runtime) {
     function line(segments) {
         return ui.jsx("text", { wrapMode: "none", children: segments.length === 0 ? " " : segments.map(span) });
     }
-    function viewFor(sessionID, now) {
-        const source = missionStateFromV2(context.data, directory);
-        const records = { work: readWork(root, sessionID), research: readLatestResearchRun(root) };
-        return buildMissionView(readMissionInput(source, sessionID, readLedger(root), now, {
-            ...(records.work === undefined ? {} : { work: records.work }),
-            ...(records.research === undefined ? {} : { research: records.research })
-        }));
+    function state() {
+        return missionStateFromV2(context.data, directory);
+    }
+    function parentOf(sessionID) {
+        const parent = context.data.session.get?.(sessionID)?.parentID;
+        return typeof parent === "string" && parent !== "" ? parent : undefined;
+    }
+    function width() {
+        return ui.useTerminalDimensions?.()().width ?? defaultWidth;
+    }
+    function rainbowOn(entry, now) {
+        return colorAllowed && rainbowShows(rainbowActive(entry.view, entry.card.chips, entry.card.busy), entry.rainbowSeen, entry.lastPromptAt, now);
+    }
+    function bandStepping(entry) {
+        if (!colorAllowed)
+            return false;
+        if (entry.waiting || rainbowOn(entry, Date.now()))
+            return true;
+        return entry.card.threads?.some((row) => row.status === "working" && row.done === undefined) === true;
+    }
+    function syncBandTimer() {
+        if (disposed)
+            return;
+        const needed = [...sessions.values()].some(bandStepping);
+        if (needed && bandTimer === undefined)
+            bandTimer = setInterval(() => {
+                setClock(Date.now());
+                syncBandTimer();
+            }, rainbowTickMs);
+        if (!needed && bandTimer !== undefined) {
+            clearInterval(bandTimer);
+            bandTimer = undefined;
+        }
     }
     function anyMoving(now) {
         for (const entry of sessions.values())
-            if (sampleMotion(entry.motion, now).moving)
+            if (sampleMotion(entry.motion, now).moving || chipShimmer(entry.chipMotion, now) !== undefined)
                 return true;
         return false;
     }
@@ -95,11 +157,103 @@ export async function setupLitOpenCodeTui(context, runtime) {
             }
         }, motionTiming.frameMs);
     }
+    // The live step's elapsed time is the one steady change: a tick a second while a tool runs.
+    function syncLiveTick() {
+        if (disposed)
+            return;
+        const running = [...sessions.values()].some((entry) => entry.view.live !== undefined);
+        if (running && liveTimer === undefined)
+            liveTimer = setInterval(() => setClock(Date.now()), liveTickMs);
+        if (!running && liveTimer !== undefined) {
+            clearInterval(liveTimer);
+            liveTimer = undefined;
+        }
+    }
+    // The card keeps the tallest lane count it reached while lanes are live or a turn runs, so the prompt does not jump.
+    function holdRows(held, rows, busy) {
+        if (rows > 0)
+            return Math.max(held, rows);
+        return busy ? held : 0;
+    }
     function ignitionToast(sessionID, name) {
         const label = `${ignitionLine(name)} 🔥`;
         const message = supportsMarkGlyphs() ? [...micro.map((row) => row.replace(/ +$/u, "")), label].join("\n") : label;
         context.ui.toast.show({ title: "🔥 LIT IGNITED", message, variant: "warning", duration: ignitionToastMs, sessionID });
     }
+    // The finish alert is off unless the plugin options opt in; OpenCode's own attention settings still
+    // decide whether a desktop notification or a sound actually plays.
+    function alertFinish(notice) {
+        if (!notify.enabled || context.attention === undefined)
+            return;
+        void context.attention
+            .notify({ title: "🔥 LIT complete", message: notice.message, notification: notify.desktop, sound: notify.sound ? { name: "done" } : false })
+            .catch(() => undefined);
+    }
+    async function checkRestart() {
+        const loaded = await readPackageMetadata().catch(() => undefined);
+        if (loaded === undefined || disposed)
+            return;
+        const target = restartVersion(loaded.version, await readInstalledVersions(loaded.packageRoot).catch(() => []));
+        if (disposed || target === undefined || target === restartTo())
+            return;
+        if (restartTo() === undefined) {
+            context.ui.toast.show({ variant: "info", title: "🔥 LIT", message: `LitOpenCode ${target} is installed. Restart OpenCode to load it.`, duration: toastMs });
+        }
+        setRestartTo(target);
+    }
+    // One toast per session, for a fresh root session in a workspace that has earlier work to pick up.
+    function suggestAdhd(sessionID, source) {
+        if (suggested.has(sessionID) || parentOf(sessionID) !== undefined)
+            return;
+        suggested.add(sessionID);
+        const created = context.data.session.get?.(sessionID)?.time?.created;
+        const now = Date.now();
+        if (source.session.messages(sessionID).length > 0 || typeof created !== "number" || now - created > 2 * 60_000)
+            return;
+        const projectRoot = missionProjectRoot(source.path);
+        if (projectRoot === undefined || !hasEarlierWork(projectRoot, sessionID, now, earlierWorkWindowMs) || !adhdSuggestDue(suggestedDays, projectRoot, now))
+            return;
+        context.ui.toast.show({ variant: "info", title: "🔥 LIT", message: "Earlier work here. Say lit adhd to pick up where you left off.", duration: toastMs });
+    }
+    // One session's view, card and the notices from its previous entry. Pure reads; nothing is armed here.
+    function build(sessionID, entry, now) {
+        const source = state();
+        const work = readWork(root, sessionID);
+        const research = readLatestResearchRun(root);
+        const view = buildMissionView(readMissionInput(source, sessionID, readLedger(root), now, {
+            ...(work === undefined ? {} : { work }),
+            ...(research === undefined ? {} : { research })
+        }));
+        const threads = threadsOf(readThreadSources(source, sessionID, root, now), now);
+        const times = messageTimes(source, sessionID);
+        const card = {
+            ...readCardInput(source, sessionID),
+            ...(threads === undefined ? {} : { threads }),
+            ...(wayBackDue(times.lastAt, now, hasEarlierWork(root, sessionID, now, earlierWorkWindowMs)) ? { earlier: true } : {})
+        };
+        const viewChanged = entry === undefined || JSON.stringify(entry.view) !== JSON.stringify(view);
+        const rainbowSeen = rainbowActive(view, card.chips, card.busy) ? now : entry?.rainbowSeen;
+        const waiting = waitingOnYou(view, card.busy, { asked: card.asked === true, userSpokeLast: card.userSpokeLast === true, blockedReply: card.blockedReply === true, boundary: work?.boundary === true });
+        const changed = entry === undefined || viewChanged || entry.lastPromptAt !== times.lastPromptAt || JSON.stringify(entry.card) !== JSON.stringify(card) || entry.rainbowSeen !== rainbowSeen || entry.waiting !== waiting;
+        const lanesChanged = entry !== undefined && JSON.stringify(entry.card.threads) !== JSON.stringify(card.threads);
+        const notices = entry !== undefined && (viewChanged || lanesChanged)
+            ? [...missionNotices(entry.view, view), ...v2StageNotices(entry.view, view, entry.card.threads ?? [], card.threads ?? [])]
+            : [];
+        return {
+            changed,
+            notices,
+            next: {
+                view,
+                card,
+                motion: entry !== undefined && viewChanged ? planMotion(entry.view, view, now, entry.motion, motionEnabled) : (entry?.motion ?? idleMotion),
+                chipMotion: planChipMotion(entry?.card.chips, card.chips, now, entry?.chipMotion ?? idleChipMotion, motionEnabled),
+                reserve: holdRows(entry?.reserve ?? 0, threadLineCount(threads), card.busy),
+                ...(rainbowSeen === undefined ? {} : { rainbowSeen }),
+                ...(times.lastPromptAt === undefined ? {} : { lastPromptAt: times.lastPromptAt }),
+                waiting
+            }
+        };
+    }
     function refresh(sessionID) {
         if (disposed)
             return;
@@ -110,19 +264,23 @@ export async function setupLitOpenCodeTui(context, runtime) {
             if (mark !== undefined && mark.at >= (trackedAt.get(sessionID) ?? 0) - historySlackMs)
                 ignitionToast(sessionID, mark.name);
         }
-        const next = viewFor(sessionID, now);
         const entry = sessions.get(sessionID);
-        if (entry !== undefined && JSON.stringify(entry.view) === JSON.stringify(next))
+        const { next, changed, notices } = build(sessionID, entry, now);
+        if (!changed)
             return;
-        if (entry !== undefined) {
-            const notice = leadingNotice(missionNotices(entry.view, next));
-            if (notice !== undefined)
-                context.ui.toast.show({ variant: notice.variant, title: notice.title, message: notice.message, duration: toastMs, sessionID });
-        }
-        sessions.set(sessionID, { view: next, motion: planMotion(entry?.view, next, now, entry?.motion ?? idleMotion, motionEnabled) });
+        const notice = leadingNotice(notices);
+        if (notice !== undefined)
+            context.ui.toast.show({ variant: notice.variant, title: notice.title, message: notice.message, duration: toastMs, sessionID });
+        const finish = notices.find((candidate) => candidate.celebrate === true);
+        if (finish !== undefined)
+            alertFinish(finish);
+        sessions.set(sessionID, next);
         setClock(now);
         setRevision(revision() + 1);
         ensureFrames();
+        syncBandTimer();
+        syncLiveTick();
+        syncPoll();
     }
     function syncPoll() {
         if (disposed)
@@ -164,8 +322,13 @@ export async function setupLitOpenCodeTui(context, runtime) {
         const now = Date.now();
         trackedAt.set(sessionID, now);
         ignitions.set(sessionID, latestLitMarkV2(context.data, sessionID)?.messageID);
-        sessions.set(sessionID, { view: viewFor(sessionID, now), motion: idleMotion });
-        queueMicrotask(syncPoll);
+        suggestAdhd(sessionID, state());
+        sessions.set(sessionID, build(sessionID, undefined, now).next);
+        queueMicrotask(() => {
+            syncPoll();
+            syncLiveTick();
+            syncBandTimer();
+        });
         // Opening a session loads its messages over HTTP, which raises no event. Reading the host's reactive
         // store here re-runs this effect as they arrive, so a resumed session lights up too.
         const dispose = ui.createRoot((release) => {
@@ -184,6 +347,60 @@ export async function setupLitOpenCodeTui(context, runtime) {
         if (type.startsWith("session.") || type.startsWith("permission.") || type.startsWith("form."))
             scheduleRefresh();
     });
+    // Reads that only a rendered slot needs. `view` follows the reactive revision and the clock.
+    function snapshot(sessionID) {
+        revision();
+        const entry = sessions.get(sessionID);
+        const now = clock();
+        return entry === undefined ? undefined : { ...entry, frame: sampleMotion(entry.motion, now), now };
+    }
+    function statusCardRows(sessionID, inLane, columns) {
+        const current = snapshot(sessionID);
+        if (current === undefined)
+            return undefined;
+        const colors = palette();
+        const cells = columns - 2;
+        const last = current.view.active ? undefined : lastMission(readLedger(root));
+        const shimmer = chipShimmer(current.chipMotion, current.now);
+        const lines = statusCard({
+            view: current.view,
+            frame: current.frame,
+            chips: current.card.chips,
+            busy: current.card.busy,
+            motion: motionEnabled,
+            reserve: current.reserve,
+            ...(current.card.threads === undefined ? {} : { threads: current.card.threads }),
+            ...(current.card.earlier === true ? { earlier: true } : {}),
+            ...(current.waiting ? { turn: { glow: turnGlow(current.now, colorAllowed) } } : {}),
+            ...(rainbowOn(current, current.now) ? { rainbow: rainbowAt(current.now) } : {}),
+            ...(current.card.lanes !== undefined && activeSkillLook(current.view, current.card.chips, current.card.busy) === "review" ? { lanes: current.card.lanes } : {}),
+            ...(shimmer === undefined ? {} : { shimmer }),
+            figures: {
+                contextPercent: current.card.contextPercent,
+                ...(current.card.branch === undefined ? {} : { branch: current.card.branch }),
+                inLane,
+                ...(restartTo() === undefined ? {} : { restartTo: restartTo() })
+            },
+            ...(last === undefined ? {} : { last })
+        }, colors, cells);
+        const rows = lines.map(line);
+        const detail = band.card ? bandCard(current.view, current.frame, colors, cells) : undefined;
+        if (detail !== undefined) {
+            rows.push(ui.jsx("box", {
+                border: true,
+                borderStyle: "rounded",
+                borderColor: detail.border,
+                title: detail.title,
+                titleColor: colors.text,
+                paddingLeft: 1,
+                paddingRight: 1,
+                flexShrink: 0,
+                flexDirection: "column",
+                children: detail.rows.map(line)
+            }));
+        }
+        return rows;
+    }
     const releases = [
         context.ui.slot({
             append: "prompt.footer.status",
@@ -192,14 +409,25 @@ export async function setupLitOpenCodeTui(context, runtime) {
                 if (sessionID === undefined)
                     return null;
                 track(sessionID);
+                const columns = width;
                 return () => {
                     revision();
                     const mark = latestLitMarkV2(context.data, sessionID);
                     if (mark === undefined)
                         return null;
+                    const ignition = ignitionLine(mark.name);
+                    const current = snapshot(sessionID);
+                    // The sidebar setting is not readable here, so a wide terminal is taken to have it open.
+                    const sidebar = parentOf(sessionID) === undefined && columns() > sidebarMinWidth ? sidebarCells : 0;
+                    const budget = columns() - sidebar - hostFooterCells - cellWidth(ignition);
+                    const drawn = current === undefined || !current.view.active ? [] : chipLine(current.view, current.frame, palette(), budget);
+                    const chip = lineWidth(drawn) > budget ? [] : drawn;
                     return ui.jsx("box", {
-                        flexShrink: 0,
-                        children: line([{ text: ignitionLine(mark.name), fg: palette().primary, bold: true }])
+                        flexShrink: 1,
+                        minWidth: 0,
+                        overflow: "hidden",
+                        flexDirection: "row",
+                        children: [line([{ text: ignition, fg: palette().primary, bold: true }]), ...(chip.length === 0 ? [] : [line([{ text: "  ", fg: palette().muted }]), line(chip)])]
                     });
                 };
             }
@@ -235,8 +463,52 @@ export async function setupLitOpenCodeTui(context, runtime) {
                     });
                 };
             }
+        }),
+        context.ui.slot({
+            append: "home.footer",
+            render() {
+                const columns = width;
+                return () => {
+                    revision();
+                    const segments = homeLine(lastMission(readLedger(root)), palette(), Math.min(homeLineWidth, columns() - 10));
+                    return segments.length === 0 ? null : ui.jsx("box", { flexDirection: "row", justifyContent: "center", flexShrink: 0, children: line(segments) });
+                };
+            }
         })
     ];
+    // The card is drawn once for the whole app, under the session and its sidebar, on every session, lit or
+    // not, and keeps its rows when a turn starts. A subagent session shows its parent's card as a lane. The
+    // home route has no session, so it shows no card.
+    if (band.enabled) {
+        releases.push(context.ui.slot({
+            append: "app",
+            render() {
+                const columns = width;
+                return () => {
+                    const route = context.ui.router?.current();
+                    const sessionID = route?.type === "session" ? route.sessionID : undefined;
+                    if (sessionID === undefined)
+                        return null;
+                    const parent = parentOf(sessionID);
+                    const target = parent ?? sessionID;
+                    track(target);
+                    const rows = statusCardRows(target, parent !== undefined, columns());
+                    if (rows === undefined)
+                        return null;
+                    return ui.jsx("box", {
+                        flexDirection: "column",
+                        flexShrink: 0,
+                        paddingLeft: 1,
+                        paddingRight: 1,
+                        backgroundColor: palette().panel ?? "transparent",
+                        children: rows
+                    });
+                };
+            }
+        }));
+    }
+    void checkRestart();
+    restartTimer = setInterval(() => void checkRestart(), restartCheckMs);
     return async () => {
         disposed = true;
         for (const dispose of watchers.values())
@@ -246,12 +518,18 @@ export async function setupLitOpenCodeTui(context, runtime) {
         unlisten();
         for (const release of releases)
             release();
+        if (restartTimer !== undefined)
+            clearInterval(restartTimer);
         if (frameTimer !== undefined)
             clearInterval(frameTimer);
         if (refreshTimer !== undefined)
             clearTimeout(refreshTimer);
         if (pollTimer !== undefined)
             clearInterval(pollTimer);
+        if (liveTimer !== undefined)
+            clearInterval(liveTimer);
+        if (bandTimer !== undefined)
+            clearInterval(bandTimer);
         sessions.clear();
         ignitions.clear();
         trackedAt.clear();

package/docs/assets/readme/badge-version.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="146" height="20" role="img" aria-label="release: 1.0.36"><title>release: 1.0.36</title><g shape-rendering="crispEdges"><rect width="49" height="20" fill="#080d14"/><rect x="49" width="97" height="20" fill="#ff6337"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text x="255" y="140" textLength="390" transform="scale(.1)">release</text><text x="965" y="140" textLength="870" transform="scale(.1)" fill="#080D14">1.0.36</text></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="146" height="20" role="img" aria-label="release: 1.0.37"><title>release: 1.0.37</title><g shape-rendering="crispEdges"><rect width="49" height="20" fill="#080d14"/><rect x="49" width="97" height="20" fill="#ff6337"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text x="255" y="140" textLength="390" transform="scale(.1)">release</text><text x="965" y="140" textLength="870" transform="scale(.1)" fill="#080D14">1.0.37</text></g></svg>

package/docs/reference-Ko-KR.md

@@ -380,10 +380,18 @@ Code Mode 밖, 모델의 도구 목록에 바로 있으므로 `lit-plan`도 계
   lit 프롬프트이면 프롬프트 아래 줄(`prompt.footer.status`)에 `🔥 LIT IGNITED · <discipline>`이 나옵니다.
   OpenCode 1에서는 표시가 예전 자리에 그대로 있습니다.
 - *토스트.* OpenCode 2에서는 서버가 토스트를 띄울 수 없습니다. 서버가 사용자 메시지 메타데이터에 남긴 lit 표시를
-  TUI가 보고 점화 토스트를 직접 띄웁니다. 서버만 알던 자동 인수인계 알림과 스킬 힌트는 그곳에 나오지 않습니다.
-- *TUI.* 미션 패널은 전처럼 세션 사이드바에 있습니다. OpenCode 2는 서버 플러그인과 함께 오는 TUI에 옵션을
-  넘기지 않고 할 일 목록도 두지 않으므로, 미션 진행은 ledger와 작업 기록과 계획에서 읽습니다. 세션 아래 상태 띠와
-  홈 화면 한 줄은 OpenCode 1에서만 그립니다.
+  TUI가 보고 점화 토스트를 직접 띄우고, OpenCode 1과 같은 관문 토스트(계획 저장, 목표 설정, 기준 통과, 막힘, 완료)에
+  더해 OpenCode 2에만 있는 세 가지를 띄웁니다. 작업 단계가 넘어갈 때(`🔥 Stage`, `work 3/7`), 규율이 바뀔 때
+  (`🔥 lit-loop → start-work`), 레인이 시작되거나 끝날 때입니다. 한꺼번에 일어난 일은 `+N more`가 붙은 토스트
+  하나로 합칩니다. 재시작 안내, `lit adhd` 제안, 켜 두면 나오는 완료 알림은 OpenCode 1과 같습니다. 서버만 알던
+  자동 인수인계 알림과 스킬 힌트는 그곳에 나오지 않습니다.
+- *TUI.* HUD는 OpenCode 2가 공개한 슬롯에 놓입니다. 상태 카드는 `app` 슬롯에서 세션과 사이드바 아래에 그려지고,
+  쉬든 일하든 네 줄을 유지합니다. 단계 칩은 에이전트·모델 줄 오른쪽에 슬롯이 없어서 점화 줄과 함께
+  `prompt.footer.status`에 있고, 홈 줄은 `home.footer`, 미션 패널은 `sidebar.content`에 있으므로 사이드바를 열어
+  두면 보입니다. 카드, 칩, 패널, 홈 줄은 OpenCode 1과 같은 글자 빌더를 씁니다. 플러그인 항목의 `band`, `notify`
+  옵션은 OpenCode 2가 넘겨 주는 옵션에서 읽습니다. OpenCode 2는 할 일 목록을 두지 않으므로 미션 진행은 ledger와
+  작업 기록과 계획에서 읽습니다. 도구 이름도 다릅니다(`shell`, `subagent`, `id`를 받는 `skill` 도구). 카드는 그
+  이름을 읽습니다. OpenCode 2는 플러그인에 요금제 한도 수치를 주지 않으므로 그리지 않습니다.
 - *업데이트.* OpenCode 2에서는 플러그인 안의 자동 업데이트가 없습니다. `opencode plugin update`를 실행하거나
   OpenCode 2의 업데이트 방식에 맡기면 됩니다.
 
@@ -458,7 +466,7 @@ OpenCode 1.18은 `tui.json`이나 `tui.jsonc`의 `plugin` 배열에 적힌 TUI
   - `lit-adhd`(별칭 `lit-rewind`)가 도는 동안 테두리, LIT 글자, 게이지가 같은 밝기의 색상환을 따라 돕니다.
     1초에 네 번 색이 조금씩 바뀌고 깜박이지 않습니다. `motion: false`와 `NO_COLOR`에서는 꺼집니다. 이전
     작업이 있는 작업 공간의 쉬는 세션은 `lit adhd to pick up where you left off`를 보여 주고, 그곳에서 처음 연
-    새 세션은 같은 문구로 토스트를 한 번 띄웁니다(v1 TUI만. v2 TUI에는 띠도 토스트도 없습니다).
+    새 세션은 같은 문구로 토스트를 한 번 띄웁니다(OpenCode 1과 2 모두).
   - 카드의 모양은 한 번에 하나이고, `src/tui/mission-looks.ts`의 작은 목록에서 고릅니다. lit-adhd를 실행하는
     길은 모두 되감기 모양이 됩니다. 채팅의 `lit adhd`/`lit rewind`, `/lit-adhd`/`/lit-rewind`(v2에 설치된 별칭
     파일에서 온 것도 포함), 네이티브 `skill` 로드가 그렇습니다. 세션이 사용자를 기다리는 동안(권한 요청이나 질문,

package/docs/reference.md

@@ -498,12 +498,22 @@ settings but does not send them yet.
   TUI: the line under the prompt (`prompt.footer.status`) reads `🔥 LIT IGNITED · <discipline>` while the
   latest prompt of the session is a lit prompt. On OpenCode 1 the mark stays where it was.
 - *Toasts.* The server cannot show toasts on OpenCode 2. The TUI raises the ignition toast itself when a
-  user message arrives with the lit mark the server writes into its metadata. The automatic-handoff
-  notices and the skill hint, which only the server knew about, are not shown there.
-- *TUI.* The mission panel sits in the session sidebar as before. OpenCode 2 passes no options to a TUI
-  that comes with a server plugin, and it keeps no todo list, so mission progress comes from the ledger,
-  the work record and the plan. The status band under the session and the home-screen line are drawn on
-  OpenCode 1 only.
+  user message arrives with the lit mark the server writes into its metadata, and it raises the same gate
+  toasts as OpenCode 1 (plan saved, goal set, criterion passed, blockers, complete) plus three more that
+  only OpenCode 2 has: the workflow stage moving (`🔥 Stage`, `work 3/7`), a switch of discipline
+  (`🔥 lit-loop → start-work`) and a lane starting or finishing. A burst folds into one toast with a
+  `+N more` tail. The restart notice, the `lit adhd` suggestion and the opt-in finish alert work as on
+  OpenCode 1. The automatic-handoff notices and the skill hint, which only the server knew about, are
+  not shown there.
+- *TUI.* The HUD is placed in the slots OpenCode 2 publishes: the status card is claimed in `app`, under
+  the session and the sidebar, and keeps its four rows idle or working; the stage chip shares
+  `prompt.footer.status` with the ignition line, because there is no slot right of the agent and model
+  row; the home line is in `home.footer`; the mission panel sits in `sidebar.content`, so it shows when
+  the sidebar is open. The card, chip, panel and home line use the same text builders as OpenCode 1. The
+  `band` and `notify` options of the plugin entry are read from the options OpenCode 2 hands over. OpenCode 2
+  keeps no todo list, so mission progress comes from the ledger, the work record and the plan. It names
+  its tools differently (`shell`, `subagent`, a `skill` tool that takes `id`), and the card reads those
+  names. OpenCode 2 gives plugins no rate-limit figures, so none are drawn.
 - *Updates.* There is no automatic self-update inside the plugin on OpenCode 2. Run
   `opencode plugin update`, or let OpenCode 2's own update policy handle it.
 
@@ -586,7 +596,7 @@ What it draws:
     the colour wheel at one fixed lightness, four small colour steps a second with no flashing. It
     is off under `motion: false` and `NO_COLOR`. An idle session in a workspace with earlier work
     says `lit adhd to pick up where you left off`, and the first fresh session there raises one
-    toast with the same words (v1 TUI only; the v2 TUI has no band and no toast).
+    toast with the same words (OpenCode 1 and 2).
   - one look at a time, picked from a small registry in `src/tui/mission-looks.ts`. Every route that runs
     lit-adhd wears the rewind look: `lit adhd`/`lit rewind` in chat, `/lit-adhd`/`/lit-rewind` (also from an
     installed v2 alias file) and a native `skill` load. While the session waits on you (a permission or a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litfamily/litopencode",
-  "version": "1.0.36",
+  "version": "1.0.37",
   "description": "Workflow plugin for OpenCode: add lit to a prompt and the work is planned, built, checked and written down so the next session can pick it up.",
   "keywords": [
     "opencode",

package/skills/lit-typographic-motion/engine/cover/render.mjs

@@ -108,7 +108,7 @@ function prepare(out) {
   const cover = loadCoverTreatment(out);
   const coverDir = path.join(out, "cover");
   if (!existsSync(path.join(coverDir, "index.html"))) throw stop(EXIT.STAGE_CONTRACT_ERROR, "STAGE_CONTRACT_ERROR", `no cover page at ${path.join(coverDir, "index.html")}; write it first (references/cover.md)`);
-  const scan = scanStage(coverDir);
+  const scan = scanStage(coverDir, { clips: false });
   const assets = checkAssets({ out, treatment: cover, rasters: scan.rasters });
   const state = inspectWarmState();
   if (state.blocked) throw stop(state.blocked.exit, state.blocked.name, `${state.blocked.detail}; fix: ${state.fix}`);

package/skills/lit-typographic-motion/engine/stage/capture.mjs

@@ -6,7 +6,7 @@ import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync } from "node:
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { chromeFlagRungs } from "../constants.mjs";
-import { StageError, contentTypes, insideDir } from "./scan.mjs";
+import { StageError, clipsScript, contentTypes, insideDir } from "./scan.mjs";
 
 export const stageHost = "lit.stage";
 export const stageOrigin = `http://${stageHost}`;
@@ -108,7 +108,8 @@ export async function openStage(chromium, { chromePath, profile, stageDir, width
     const line = String(error?.message ?? error).split("\n").find((part) => part.trim()) ?? String(error);
     throw Object.assign(new Error(`BLOCKED_NO_CHROME (10): Chrome failed to launch headless: ${line}; fix: check that Chrome can start headless in this sandbox`), { exitCode: 10 });
   }
-  const { blocked, refused, missing } = await serveStage(context, { stageDir, fonts, scripts: { "/lit/stage-kit.js": kitSource(), ...styleFiles } });
+  const clips = clipsScript(stageDir);
+  const { blocked, refused, missing } = await serveStage(context, { stageDir, fonts, scripts: { "/lit/stage-kit.js": kitSource(), ...(clips ? { "/lit/clips.js": clips } : {}), ...styleFiles } });
   await context.addInitScript({ content: `window.__litStageConfig = ${JSON.stringify({ seed: seed >>> 0, fps })};\n${clockSource()}` });
   if (extraInit) await context.addInitScript({ content: extraInit });
   const page = context.pages()[0] ?? await context.newPage();

package/skills/lit-typographic-motion/engine/stage/gate.mjs

@@ -146,6 +146,7 @@ export function formatStageReport(result, context) {
     `outputs: ${out("film.mp4")} · ${out(manifest.previewEncoder === "gif" ? "preview.gif" : "preview.webp")} (encoder: ${manifest.previewEncoder}) · ${out("poster.png")} · ${out("reduced-motion.png")}`,
     `format / fps / length: ${manifest.format} ${manifest.resolution.join("x")} @ ${manifest.fps} fps, ${manifest.durationSec.toFixed(2)} s (treatment ${manifest.targetDurationSec} s)`,
     `renderer: stage ${manifest.rung === "gpu" ? `GPU rung (${manifest.renderer ?? "native ANGLE"})` : "software rung"} (flags: ${(manifest.chromeFlags ?? []).join(" ")})`,
+    ...(manifest.clips?.length ? [`clips: ${manifest.clips.map((clip) => `${clip.id} ${clip.frames} frames at ${clip.fps} fps`).join(", ")} (keyed overlays, chosen from film time)`] : []),
     ...(manifest.warnings ?? []).map((note) => `notice: ${note}`),
     `timing: master ${manifest.timing?.masterSec ?? "?"} s, per frame p50 ${manifest.timing?.frameP50 ?? "?"} ms / p95 ${manifest.timing?.frameP95 ?? "?"} ms, total ${manifest.timing?.totalSec ?? "?"} s`,
     "",

package/skills/lit-typographic-motion/engine/stage/render.mjs

@@ -450,6 +450,7 @@ export async function renderStage(out, { round = 1, stillsOnly = false } = {}) {
       preview: preview ? { width: preview.width, height: preview.height, fps: preview.fps, bytes: preview.bytes } : null,
       posterFrame, posterSize: [poster.width, poster.height], stillFrame, determinismFrames: samples,
       timing: { ...master.timing, totalSec: Number(((performance.now() - began) / 1000).toFixed(1)) },
+      ...(context.scan.clips.length ? { clips: context.scan.clips.map((clip) => ({ id: clip.id, frames: clip.count, fps: clip.fps, width: clip.width, height: clip.height, bytes: clip.bytes })) } : {}),
       ...(context.plate ? { plate: { blender: context.plate.blender, engine: context.plate.engine, device: context.plate.device, samples: context.plate.samples, fps: context.plate.fps, frames: context.plate.frames.length } } : {}),
       sound, qa: { file: ".run/qa.json", samples: qaResult.samples.length, trackFrames: qaResult.trackFrames, allowedFaces: qaResult.allowedFaces },
       treatmentSha256: sha256(readFileSync(path.join(out, "treatment.json"))), stageSha256: stageSha(context.stageDir),