@litfamily/litopencode 1.0.36 → 1.0.38

package/dist/v2/tui.js

@@ -1,26 +1,57 @@
-// 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 { latestLitMarkV2, missionStateFromV2, sessionMessagesV2 } from "../tui/mission-source-v2.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 { homeLine, missionPanel, paletteFromTheme, panelWidth } from "../tui/mission-text.js";
+import { createRuntimePaths } from "../state.js";
+import { footerBudget, footerStatus, sidebarCells } from "./tui-footer.js";
+import { createNoticeTail } from "./notices.js";
+import { v2StageNotices } from "./tui-notices.js";
+import { createUsageLimits } from "./usage-limits.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;
+const sidebarMinWidth = 120;
+// The plan windows change slowly; asking the host more than once a minute would only add requests.
+const limitsPollMs = 60_000;
+// Only the OpenCode Go allowance has a source on OpenCode 2, so the windows belong to a Go session alone.
+const goProviderID = "opencode-go";
+const noticeBurst = 3;
 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 +73,54 @@ 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 readUsage = context.client?.usage?.limits;
+    const limits = createUsageLimits({
+        read: readUsage === undefined ? undefined : () => readUsage.call(context.client?.usage),
+        now: Date.now,
+        intervalMs: limitsPollMs,
+        onChange: () => setRevision(revision() + 1)
+    });
+    const noticeTail = createNoticeTail(root === undefined ? "" : createRuntimePaths(root).noticesFile);
+    // The provider of the session's latest assistant message decides whether the Go allowance applies to it.
+    function goSession(sessionID) {
+        const latest = sessionMessagesV2(context.data, sessionID).filter((message) => message.type === "assistant").at(-1);
+        return latest?.model?.providerID === goProviderID;
+    }
+    // Popups the server could not raise (the automatic handoff) arrive as lines in the notices file.
+    function showServerNotices() {
+        if (disposed)
+            return;
+        for (const notice of noticeTail.poll().slice(-noticeBurst)) {
+            context.ui.toast.show({ title: notice.title, message: notice.message, variant: notice.variant, duration: notice.duration });
+        }
+    }
     const palette = () => paletteFromV2Theme(context.theme, context.themeMode);
     function span(segment) {
         return ui.jsx("span", {
@@ -69,17 +131,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 +183,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 +290,25 @@ 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);
+        if (goSession(sessionID))
+            void limits.poll();
         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)
@@ -141,6 +327,7 @@ export async function setupLitOpenCodeTui(context, runtime) {
             return;
         for (const sessionID of tracked)
             refresh(sessionID);
+        showServerNotices();
         syncPoll();
     }
     function scheduleRefresh() {
@@ -164,8 +351,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 +376,61 @@ 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,
+                ...(goSession(sessionID) && limits.windows().length > 0 ? { limits: limits.windows() } : {}),
+                ...(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 +439,30 @@ 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 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;
+                    const footer = footerStatus({
+                        name: mark.name,
+                        view: current?.view,
+                        frame: current?.frame ?? sampleMotion(idleMotion, clock()),
+                        palette: palette(),
+                        budget: footerBudget({ columns: columns(), sidebar, busy: current?.card.busy === true })
+                    });
+                    if (footer.length === 0)
+                        return null;
                     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(footer)
                     });
                 };
             }
@@ -235,8 +498,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 +553,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/dist/v2/usage-limits.d.ts

@@ -0,0 +1,19 @@
+export type LimitWindow = {
+    readonly label: "5h" | "1w" | "1mo";
+    readonly percent: number;
+    readonly limited: boolean;
+};
+/** Reads the usage-limits reply (`{ data: Info | null }` or the bare Info) into the windows worth drawing. */
+export declare function limitWindows(reply: unknown): readonly LimitWindow[];
+export type UsageLimitsOptions = {
+    /** Asks the host; absent when the host has no usage source. */
+    readonly read: (() => Promise<unknown>) | undefined;
+    readonly now: () => number;
+    readonly intervalMs: number;
+    readonly onChange: () => void;
+};
+/** A throttled reader: it asks at most once per interval, and a failed or empty answer clears the figures. */
+export declare function createUsageLimits(options: UsageLimitsOptions): {
+    readonly windows: () => readonly LimitWindow[];
+    readonly poll: () => Promise<void>;
+};

package/dist/v2/usage-limits.js

@@ -0,0 +1,70 @@
+// The plan windows OpenCode 2 can tell a plugin about. Its one usage source is client.usage.limits(): the
+// OpenCode Go allowance of the Console workspace the location is signed in to, as a rolling window (five
+// hours), a weekly one and a monthly one, each with a percent used; the reply is null when nobody is signed
+// in. There are no provider response headers or rate-limit events for a plugin to read, so for any other
+// provider this module has nothing to show, and the card draws no figure rather than a made-up one.
+/** The monthly window is shown only when it is close to the cap, so the card keeps LitClaude's 5h and 1w pair. */
+const monthlyShowPercent = 90;
+function record(value) {
+    return typeof value === "object" && value !== null ? value : undefined;
+}
+function window(label, raw) {
+    const meter = record(raw);
+    const percent = meter?.percent;
+    if (typeof percent !== "number" || !Number.isFinite(percent))
+        return undefined;
+    return { label, percent: Math.round(Math.min(100, Math.max(0, percent))), limited: meter?.limited === true };
+}
+/** Reads the usage-limits reply (`{ data: Info | null }` or the bare Info) into the windows worth drawing. */
+export function limitWindows(reply) {
+    const outer = record(reply);
+    const info = outer === undefined ? undefined : "data" in outer ? record(outer.data) : outer;
+    const allowance = record(info?.go);
+    if (allowance === undefined)
+        return [];
+    const rolling = window("5h", allowance.rolling);
+    const weekly = window("1w", allowance.weekly);
+    const monthly = window("1mo", allowance.monthly);
+    return [
+        ...(rolling === undefined ? [] : [rolling]),
+        ...(weekly === undefined ? [] : [weekly]),
+        ...(monthly !== undefined && (monthly.limited || monthly.percent >= monthlyShowPercent) ? [monthly] : [])
+    ];
+}
+/** A throttled reader: it asks at most once per interval, and a failed or empty answer clears the figures. */
+export function createUsageLimits(options) {
+    let current = [];
+    let askedAt;
+    let pending;
+    async function ask(read) {
+        let next;
+        try {
+            next = limitWindows(await read());
+        }
+        catch { // no-excuse-ok: catch -- an unreachable or signed-out host means there is nothing to show, never an error on screen.
+            next = [];
+        }
+        if (JSON.stringify(next) === JSON.stringify(current))
+            return;
+        current = next;
+        options.onChange();
+    }
+    return {
+        windows: () => current,
+        poll() {
+            const read = options.read;
+            if (read === undefined)
+                return Promise.resolve();
+            if (pending !== undefined)
+                return pending;
+            const now = options.now();
+            if (askedAt !== undefined && now - askedAt < options.intervalMs)
+                return Promise.resolve();
+            askedAt = now;
+            pending = ask(read).finally(() => {
+                pending = undefined;
+            });
+            return pending;
+        }
+    };
+}

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.38"><title>release: 1.0.38</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.38</text></g></svg>

package/docs/reference-Ko-KR.md

@@ -380,10 +380,29 @@ 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과 같습니다. 서버만 알던
+  자동 인수인계 알림은 `.litopencode/notices.jsonl`을 거쳐 화면에 나옵니다. OpenCode 2 서버 플러그인은 이벤트를
+  구독할 수만 있고 토스트를 띄울 수 없으므로, 서버가 알림을 그 파일에 한 줄씩 덧붙이면 TUI 플러그인이 시작한 뒤에
+  생긴 줄을 토스트로 보여 줍니다(파일 크기에 상한이 있고 심볼릭 링크는 따라가지 않습니다). 서버가 띄우던 나머지
+  하나인 점화 토스트는 이미 TUI가 직접 띄우므로, 따로 옮길 스킬 힌트는 남아 있지 않습니다.
+- *TUI.* HUD는 OpenCode 2가 공개한 슬롯에 놓입니다. 상태 카드는 `app` 슬롯에서 세션과 사이드바 아래에 그려지고,
+  쉬든 일하든 네 줄을 유지합니다. 단계 칩은 에이전트·모델 줄 오른쪽에 슬롯이 없어서 점화 줄과 함께
+  `prompt.footer.status`에 있고, 홈 줄은 `home.footer`, 미션 패널은 `sidebar.content`에 있으므로 사이드바를 열어
+  두면 보입니다. 카드, 칩, 패널, 홈 줄은 OpenCode 1과 같은 글자 빌더를 씁니다. 플러그인 항목의 `band`, `notify`
+  옵션은 OpenCode 2가 넘겨 주는 옵션에서 읽습니다. 푸터 줄은 호스트가 잘라 버리게 두지 않고 터미널 너비에 맞춰
+  단계적으로 줄어듭니다. 표시와 전체 칩, 표시와 작은 칩, 칩만, `🔥 1/3`, 불꽃만, 아무것도 없음 순서입니다. 쓸 수 있는
+  너비는 전체 너비에서 사이드바(120칸을 넘으면 열려 있다고 가정)와 호스트 자신의 스피너·수치를 뺀 값입니다.
+  OpenCode 2는 할 일 목록을 두지 않으므로 미션 진행은 ledger와
+  작업 기록과 계획에서 읽습니다. 도구 이름도 다릅니다(`shell`, `subagent`, `id`를 받는 `skill` 도구). 카드는 그
+  이름을 읽습니다. OpenCode 2가 플러그인에 주는 사용량 출처는 `client.usage.limits()` 하나입니다. 위치가 로그인한
+  OpenCode Console 작업 공간의 OpenCode Go 허용량(5시간 롤링, 주간, 월간 창)입니다. 마지막 답변이 `opencode-go`
+  제공자에서 온 세션이면 카드 아래 테두리에 컨텍스트 수치 뒤로 `5h 42% · 1w 18%`가 나옵니다(월간 창은 90% 이상일
+  때만, 호스트가 요청을 거부 중이라고 알리는 창은 `limited`로 표시). 호출은 1분에 한 번 이하입니다. 다른 제공자,
+  로그아웃 상태(응답이 `null`), 오류일 때는 아무것도 그리지 않습니다. OpenCode 2는 제공자 속도 제한 헤더나 이벤트를
+  플러그인에 노출하지 않으므로 Anthropic·OpenAI 요금제의 5시간·주간 수치는 없습니다.
 - *업데이트.* OpenCode 2에서는 플러그인 안의 자동 업데이트가 없습니다. `opencode plugin update`를 실행하거나
   OpenCode 2의 업데이트 방식에 맡기면 됩니다.
 
@@ -458,7 +477,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` 로드가 그렇습니다. 세션이 사용자를 기다리는 동안(권한 요청이나 질문,