@litfamily/litopencode 1.0.31 → 1.0.32

package/dist/tui/mission-source.js

@@ -4,7 +4,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { planChecklist, readLitMark, readWorkState } from "./mission-model.js";
+import { isLaneResult, isReviewLane } from "./mission-looks.js";
 import { readSkillUse, skillChips } from "./mission-skills.js";
+import { isRealCount } from "./mission-threads.js";
+import { readSiblingStacksSync, readStackSync } from "../workflow-stack.js";
 const ledgerByteLimit = 1024 * 1024;
 /** The same root the server plugin uses: the worktree unless it is the filesystem root, else the directory. */
 export function missionProjectRoot(paths) {
@@ -67,7 +70,7 @@ export function createWorkReader() {
             return undefined;
         const inside = work.planPath !== "" && path.isAbsolute(work.planPath) && !path.relative(path.resolve(root), work.planPath).startsWith("..");
         const plan = inside ? readPlan(work.planPath) : undefined;
-        return { status: work.status, iterations: work.iterations, ...(plan === undefined ? {} : { plan }) };
+        return { status: work.status, iterations: work.iterations, ...(plan === undefined ? {} : { plan }), ...(work.boundary === true ? { boundary: true } : {}) };
     };
 }
 function lstatOrUndefined(file) {
@@ -235,6 +238,35 @@ export function readMissionInput(state, sessionID, ledger, now, records = {}) {
         now
     };
 }
+/** A completed `review-work` call with action `lane`: one lane's reported result. */
+export function readLaneReport(part) {
+    if (!isRecord(part) || part.type !== "tool" || part.tool !== "review-work" || !isRecord(part.state) || part.state.status !== "completed")
+        return undefined;
+    const input = isRecord(part.state.input) ? part.state.input : {};
+    if (input.action !== "lane" || !isReviewLane(input.lane) || !isLaneResult(input.result))
+        return undefined;
+    return { lane: input.lane, result: input.result };
+}
+/**
+ * True when the reply's first line of prose opens with `BLOCKED:`. The ignition mark comes first on the
+ * host (a fenced LIT block from experimental.text.complete, and the model's `LIT IGNITED` line), so those
+ * lines and blank ones are passed over; anything else ends the search.
+ */
+export function opensBlocked(parts) {
+    const text = parts.map((part) => (isRecord(part) && part.type === "text" && typeof part.text === "string" ? part.text : "")).join("\n");
+    let fenced = false;
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("```")) {
+            fenced = !fenced;
+            continue;
+        }
+        if (fenced || trimmed === "" || trimmed.includes("LIT IGNITED"))
+            continue;
+        return /^BLOCKED:/u.test(trimmed);
+    }
+    return false;
+}
 /**
  * What the band card shows beside the mission: the session's skill chips, whether a turn is running,
  * context use and git branch. OpenCode keeps each session's last `session.status` ({ type: "busy" },
@@ -244,23 +276,173 @@ export function readCardInput(state, sessionID) {
     const messages = state.session.messages(sessionID);
     const uses = [];
     let since;
+    // A new review start clears the lanes, so the border shows only this review's reports.
+    let lanes;
     for (const message of messages) {
         const at = num(message.time?.created);
         if (message.role === "user")
             since = at;
         for (const part of state.part(message.id)) {
+            const report = readLaneReport(part);
+            if (report !== undefined) {
+                lanes = { ...lanes, [report.lane]: report.result };
+                continue;
+            }
             const use = readSkillUse(part, at);
             if (use !== undefined)
                 uses.push(use);
+            const action = isRecord(part) && isRecord(part.state) && isRecord(part.state.input) ? part.state.input.action : undefined;
+            if (use?.name === "review-work" && action !== "status" && action !== "lane")
+                lanes = {};
         }
     }
     const status = state.session.status(sessionID)?.type;
     const busy = status === "busy" || status === "retry";
     const branch = state.vcs?.branch?.trim();
+    const last = messages.at(-1);
+    const asked = state.session.permission(sessionID).length > 0 || state.session.question(sessionID).length > 0;
     return {
         chips: skillChips(uses, { since, busy }),
         busy,
         contextPercent: contextPercent(state, messages),
-        ...(branch === undefined || branch === "" ? {} : { branch })
+        ...(branch === undefined || branch === "" ? {} : { branch }),
+        ...(lanes === undefined ? {} : { lanes }),
+        ...(asked ? { asked } : {}),
+        ...(last?.role === "user" ? { userSpokeLast: true } : {}),
+        ...(last?.role === "assistant" && opensBlocked(state.part(last.id)) ? { blockedReply: true } : {})
     };
 }
+export const earlierWorkWindowMs = 7 * 24 * 60 * 60_000;
+const siblingFreshMs = 15 * 60_000;
+const siblingMax = 6;
+const taskLingerMs = 30_000;
+const recentAssistantMessages = 3;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function countsOf(done, total) {
+    return isRealCount(done, total) ? { done, total } : {};
+}
+function taskSources(state, sessionID, now) {
+    const sources = [];
+    const children = new Set();
+    const assistants = state.session.messages(sessionID).filter((message) => message.role === "assistant").slice(-recentAssistantMessages);
+    for (const message of assistants) {
+        for (const part of state.part(message.id)) {
+            if (part.type !== "tool" || part.tool !== "task" || !isRecord(part.state))
+                continue;
+            const toolState = part.state;
+            const status = toolState.status;
+            const time = isRecord(toolState.time) ? toolState.time : {};
+            const start = typeof time.start === "number" ? time.start : undefined;
+            const end = typeof time.end === "number" ? time.end : undefined;
+            if (status !== "running" && status !== "completed" && status !== "error")
+                continue;
+            if (status !== "running" && (end === undefined || now - end > taskLingerMs))
+                continue;
+            const input = isRecord(toolState.input) ? toolState.input : {};
+            const metadata = isRecord(toolState.metadata) ? toolState.metadata : {};
+            const child = typeof metadata.sessionId === "string" ? metadata.sessionId : undefined;
+            if (child !== undefined)
+                children.add(child);
+            const todos = child === undefined ? [] : state.session.todo(child).filter((todo) => todo.status !== "cancelled");
+            const done = todos.filter((todo) => todo.status === "completed").length;
+            const name = typeof input.description === "string" && input.description.trim() !== "" ? input.description.trim() : typeof input.subagent_type === "string" ? input.subagent_type : "subagent";
+            // A running task last moved when its own session did; its start time alone would read a long, busy run as idle.
+            const moved = child === undefined ? undefined : lastActivity(state, child);
+            sources.push({
+                kind: "task",
+                name,
+                status: status === "running" ? "working" : status === "completed" ? "done" : "failed",
+                ...countsOf(done, todos.length),
+                ...(start === undefined ? {} : { startedAt: start }),
+                touchedAt: end ?? (start === undefined && moved === undefined ? now : Math.max(start ?? 0, moved ?? 0))
+            });
+        }
+    }
+    return { sources, children };
+}
+/** The latest time any message of a session was created or completed, if it has one. */
+function lastActivity(state, sessionID) {
+    let latest;
+    for (const message of state.session.messages(sessionID)) {
+        for (const at of [message.time?.created, message.time?.completed]) {
+            if (typeof at === "number" && Number.isFinite(at) && (latest === undefined || at > latest))
+                latest = at;
+        }
+    }
+    return latest;
+}
+function stackSources(stack) {
+    return (stack?.frames ?? []).map((frame) => ({
+        kind: "stack",
+        name: frame.skill,
+        status: frame.status === "active" ? "working" : "paused",
+        ...countsOf(frame.done, frame.total),
+        ...(frame.phase === undefined ? {} : { phase: frame.phase }),
+        touchedAt: frame.at
+    }));
+}
+function siblingSource(stack) {
+    const top = stack.frames.find((frame) => frame.status === "active") ?? stack.frames[stack.frames.length - 1];
+    return {
+        kind: "session",
+        name: `${top.skill} · ${stack.sessionID.slice(-4)}`,
+        status: top.status === "active" ? "working" : "paused",
+        ...countsOf(top.done, top.total),
+        ...(top.phase === undefined ? {} : { phase: top.phase }),
+        touchedAt: stack.updatedAt
+    };
+}
+/**
+ * The lanes beside this session's own mission: its workflow stack frames, its running `task` calls and
+ * the stacks of other sessions in the workspace that moved in the last fifteen minutes. Only counts
+ * that are real totals are carried; the input of a tool call is read for its description alone.
+ */
+export function readThreadSources(state, sessionID, root, now) {
+    const tasks = taskSources(state, sessionID, now);
+    if (root === undefined)
+        return tasks.sources;
+    const siblings = readSiblingStacksSync(root, sessionID, { now, freshMs: siblingFreshMs, max: siblingMax }).filter((stack) => !tasks.children.has(stack.sessionID));
+    return [...stackSources(readStackSync(root, sessionID)), ...tasks.sources, ...siblings.map(siblingSource)];
+}
+/**
+ * Whether earlier work exists for the band's idle hint and the one suggestion: another session here
+ * touched its workflow stack within `withinMs`.
+ */
+/** When the session's last message and its last user prompt were created, from the reactive store. */
+export function messageTimes(state, sessionID) {
+    let lastAt;
+    let lastPromptAt;
+    for (const message of state.session.messages(sessionID)) {
+        const created = message.time?.created;
+        if (typeof created !== "number")
+            continue;
+        if (lastAt === undefined || created > lastAt)
+            lastAt = created;
+        if (message.role === "user" && (lastPromptAt === undefined || created > lastPromptAt))
+            lastPromptAt = created;
+    }
+    return { ...(lastAt === undefined ? {} : { lastAt }), ...(lastPromptAt === undefined ? {} : { lastPromptAt }) };
+}
+/** The way back in is offered after this long without a message in the session. */
+export const adhdBreakMs = 30 * 60_000;
+/** The idle card names lit adhd in a fresh session or after a break, only when earlier work exists. */
+export function wayBackDue(lastActivityAt, now, earlier) {
+    return earlier && (lastActivityAt === undefined || now - lastActivityAt >= adhdBreakMs);
+}
+function localDay(at) {
+    const date = new Date(at);
+    return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+}
+/** At most one start suggestion per workspace per local day; records the day when it answers true. */
+export function adhdSuggestDue(days, root, now) {
+    const day = localDay(now);
+    if (days.get(root) === day)
+        return false;
+    days.set(root, day);
+    return true;
+}
+export function hasEarlierWork(root, sessionID, now, withinMs) {
+    return root !== undefined && readSiblingStacksSync(root, sessionID, { now, freshMs: withinMs, max: 1 }).length > 0;
+}

package/dist/tui/mission-text.d.ts

@@ -53,6 +53,8 @@ export declare function chipBudget(input: {
     readonly child: boolean;
 }): number;
 export declare function cellWidth(value: string): number;
+/** Record text without terminal escape sequences or control characters; tabs and newlines become spaces later. */
+export declare function stripControls(value: string): string;
 /** Cuts `value` to at most `max` cells, ending in an ellipsis when anything was dropped. */
 export declare function truncateCells(value: string, max: number): string;
 export declare function padCells(value: string, width: number): string;

package/dist/tui/mission-text.js

@@ -120,9 +120,17 @@ export function cellWidth(value) {
         width += charWidth(char);
     return width;
 }
+// Escape and control sequences (CSI, OSC, C1) from plan rows, todos, branches or commit text would act on
+// the terminal instead of being drawn, so they are removed before any record text reaches a cell.
+const terminalSequence = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)?|\u001b[@-Z\\-_]|\u009b[0-?]*[ -/]*[@-~]|\u009d[^\u0007\u009c]*[\u0007\u009c]?/gu;
+const controlCharacter = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu;
+/** Record text without terminal escape sequences or control characters; tabs and newlines become spaces later. */
+export function stripControls(value) {
+    return value.replace(terminalSequence, "").replace(controlCharacter, "");
+}
 /** Cuts `value` to at most `max` cells, ending in an ellipsis when anything was dropped. */
 export function truncateCells(value, max) {
-    const clean = value.replace(/\s+/gu, " ").trim();
+    const clean = stripControls(value).replace(/\s+/gu, " ").trim();
     if (cellWidth(clean) <= max)
         return clean;
     if (max <= 0)

package/dist/tui/mission-threads.d.ts

@@ -0,0 +1,50 @@
+import { type Line, type MissionPalette } from "./mission-text.ts";
+export type ThreadStatus = "working" | "paused" | "done" | "failed" | "idle";
+export type ThreadSource = {
+    readonly kind: "stack" | "task" | "session";
+    readonly name: string;
+    readonly status: ThreadStatus;
+    /** Both counts or neither. */
+    readonly done?: number;
+    readonly total?: number;
+    /** A word for what is known, such as the stage a frame is on. */
+    readonly phase?: string;
+    /** When the lane started, for the elapsed time of a task. */
+    readonly startedAt?: number;
+    /** When the lane last moved; an old one reads as idle. */
+    readonly touchedAt?: number;
+};
+export type ThreadRow = {
+    readonly key: string;
+    readonly name: string;
+    readonly status: ThreadStatus;
+    readonly done?: number;
+    readonly total?: number;
+    readonly facts: string;
+};
+export declare const threadRowCap = 4;
+/** A lane untouched for this long is shown as idle rather than working. */
+export declare const idleAfterMs: number;
+export declare function isRealCount(done: unknown, total: unknown): done is number;
+/**
+ * The rows for the sources, or undefined when fewer than two lanes exist: one lane is the session's own
+ * work, which the four-row card already shows. A source untouched for five minutes reads as idle.
+ */
+export declare function threadsOf(sources: readonly ThreadSource[], now: number): ThreadRow[] | undefined;
+/** How many card rows the threads take: the fork line, the shown lanes and the `+N more` line. */
+export declare function threadLineCount(rows: readonly ThreadRow[] | undefined): number;
+/** `[▉▉▉░░░░░] 3/10` for a real total, an empty string otherwise. */
+export declare function threadGauge(done: number | undefined, total: number | undefined, cells: number): string;
+/** An indeterminate pulse: five cells that scan while motion is on, one steady frame otherwise. */
+export declare function pulseText(now: number, motion: boolean): string;
+export type ThreadDrawOptions = {
+    readonly now: number;
+    readonly motion: boolean;
+    /** A colour per gauge index while the rainbow plays; the gauge keeps the palette colour otherwise. */
+    readonly gaugeColor?: (index: number) => string;
+};
+/**
+ * The lines under the skill row: `┬ 3 lanes in parallel`, then one `├─`/`└─` line per lane (four at most;
+ * `+N more` names the rest). Each line is fitted to `width` by the caller.
+ */
+export declare function threadLines(rows: readonly ThreadRow[], palette: MissionPalette, width: number, options: ThreadDrawOptions): Line[];

package/dist/tui/mission-threads.js

@@ -0,0 +1,119 @@
+// Thread rows for the band: the lanes of work that run beside the session's own mission. A lane is a
+// frame on this session's workflow stack (a paused spine under an interjected command), a `task` tool
+// call that runs a subagent, or another session in the same workspace whose stack moved lately. The
+// module is pure: sources go in, rows and drawn lines come out.
+//
+// A gauge needs a real total. Without one a row says what is known in words (how long it has run, which
+// step it is on) and, while it is working, plays a small pulse; it never shows a question mark.
+import { cellWidth, lineWidth, truncateCells } from "./mission-text.js";
+export const threadRowCap = 4;
+/** A lane untouched for this long is shown as idle rather than working. */
+export const idleAfterMs = 5 * 60_000;
+const pulseFrames = ["▓▒░░░", "░▓▒░░", "░░▓▒░", "░░░▓▒", "░░▒▓░", "░▒▓░░"];
+const steadyPulse = "░▒▓▒░";
+const pulseMs = 250;
+const statusWordCells = 7;
+export function isRealCount(done, total) {
+    return Number.isInteger(done) && Number.isInteger(total) && total > 0 && done >= 0 && done <= total;
+}
+function minutes(from, now) {
+    if (from === undefined || !Number.isFinite(from) || from > now)
+        return undefined;
+    const total = Math.floor((now - from) / 60_000);
+    return total < 1 ? "<1m" : total < 60 ? `${total}m` : `${Math.floor(total / 60)}h${String(total % 60).padStart(2, "0")}`;
+}
+function factsFor(source, status, now) {
+    const parts = [];
+    if (source.phase !== undefined && source.phase !== "")
+        parts.push(source.phase);
+    const elapsed = minutes(source.startedAt ?? (status === "working" ? source.touchedAt : undefined), now);
+    if (elapsed !== undefined && status === "working")
+        parts.push(elapsed);
+    if (parts.length === 0)
+        parts.push(status === "done" ? "finished" : status === "failed" ? "stopped" : status === "paused" ? "held" : status === "idle" ? "quiet" : "started");
+    return parts.join(" · ");
+}
+/**
+ * The rows for the sources, or undefined when fewer than two lanes exist: one lane is the session's own
+ * work, which the four-row card already shows. A source untouched for five minutes reads as idle.
+ */
+export function threadsOf(sources, now) {
+    if (sources.length < 2)
+        return undefined;
+    return sources.map((source, index) => {
+        const status = source.status === "working" && source.touchedAt !== undefined && now - source.touchedAt > idleAfterMs ? "idle" : source.status;
+        return {
+            key: `${source.kind}:${index}:${source.name}`,
+            name: source.name,
+            status,
+            ...(isRealCount(source.done, source.total) ? { done: source.done, total: source.total } : {}),
+            facts: factsFor(source, status, now)
+        };
+    });
+}
+/** How many card rows the threads take: the fork line, the shown lanes and the `+N more` line. */
+export function threadLineCount(rows) {
+    if (rows === undefined || rows.length === 0)
+        return 0;
+    return 1 + Math.min(rows.length, threadRowCap) + (rows.length > threadRowCap ? 1 : 0);
+}
+/** `[▉▉▉░░░░░] 3/10` for a real total, an empty string otherwise. */
+export function threadGauge(done, total, cells) {
+    if (!isRealCount(done, total) || cells < 1)
+        return "";
+    const full = Math.round((done / total) * cells);
+    return `[${"▉".repeat(full)}${"░".repeat(cells - full)}] ${done}/${total}`;
+}
+/** An indeterminate pulse: five cells that scan while motion is on, one steady frame otherwise. */
+export function pulseText(now, motion) {
+    return motion ? pulseFrames[Math.floor(now / pulseMs) % pulseFrames.length] : steadyPulse;
+}
+const statusWords = { working: "working", paused: "paused", done: "done", failed: "failed", idle: "idle" };
+function statusColor(status, palette) {
+    if (status === "working")
+        return palette.info;
+    if (status === "done")
+        return palette.success;
+    if (status === "failed")
+        return palette.error;
+    if (status === "paused")
+        return palette.warning;
+    return palette.muted;
+}
+function rowLine(row, index, last, palette, width, options) {
+    const branch = { text: last ? "└─ " : "├─ ", fg: palette.borderSubtle };
+    const word = { text: statusWords[row.status].padEnd(statusWordCells), fg: statusColor(row.status, palette), bold: row.status === "working" };
+    const gap = { text: "  ", fg: palette.muted };
+    const gaugeColor = options.gaugeColor?.(index) ?? palette.accent;
+    const real = threadGauge(row.done, row.total, 8);
+    const trailing = (room) => {
+        if (real !== "" && cellWidth(real) <= room)
+            return [{ text: real, fg: gaugeColor }];
+        const facts = truncateCells(row.facts, Math.max(0, room - (row.status === "working" ? 6 : 0)));
+        const pulse = row.status === "working" ? [{ text: ` ${pulseText(options.now, options.motion)}`, fg: gaugeColor }] : [];
+        return [{ text: facts, fg: palette.muted }, ...pulse];
+    };
+    const fixed = lineWidth([branch, gap, word, gap]);
+    const room = Math.max(0, width - fixed);
+    const nameRoom = Math.max(6, Math.min(24, Math.floor(room / 2)));
+    const name = { text: truncateCells(row.name, nameRoom), fg: row.status === "idle" || row.status === "done" ? palette.muted : palette.text };
+    const pad = { text: " ".repeat(Math.max(0, Math.min(24, nameRoom) - cellWidth(name.text))), fg: palette.muted };
+    const left = [branch, name, pad, gap, word, gap];
+    return [...left, ...trailing(Math.max(0, width - lineWidth(left)))];
+}
+/**
+ * The lines under the skill row: `┬ 3 lanes in parallel`, then one `├─`/`└─` line per lane (four at most;
+ * `+N more` names the rest). Each line is fitted to `width` by the caller.
+ */
+export function threadLines(rows, palette, width, options) {
+    if (rows.length === 0)
+        return [];
+    const shown = rows.slice(0, threadRowCap);
+    const more = rows.length - shown.length;
+    const fork = [{ text: "┬ ", fg: palette.borderSubtle }, { text: `${rows.length} lanes in parallel`, fg: palette.muted }];
+    const lines = [fork];
+    shown.forEach((row, index) => lines.push(rowLine(row, index, index === shown.length - 1 && more === 0, palette, width, options)));
+    if (more > 0)
+        lines.push([{ text: "└─ ", fg: palette.borderSubtle }, { text: `+${more} more`, fg: palette.muted }]);
+    return lines;
+}

package/dist/tui.js

@@ -4,9 +4,12 @@ import { jsx } from "@opentui/solid/jsx-runtime";
 import { buildMissionView, lastMission, leadingNotice, missionNotices } from "./tui/mission-model.js";
 import { idleMotion, motionTiming, planMotion, sampleMotion } from "./tui/mission-motion.js";
 import { chipBudget, chipLine, homeLine, missionPanel, paletteFromTheme, panelWidth } from "./tui/mission-text.js";
-import { createLedgerReader, createWorkReader, missionProjectRoot, readCardInput, readLatestResearchRun, readMissionInput } from "./tui/mission-source.js";
+import { adhdSuggestDue, createLedgerReader, createWorkReader, earlierWorkWindowMs, hasEarlierWork, messageTimes, missionProjectRoot, wayBackDue, readCardInput, readLatestResearchRun, readMissionInput, readThreadSources } 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";
 export const litOpenCodeTuiPluginId = "litopencode";
 const homeLineWidth = 69;
 const refreshDelayMs = 80;
@@ -50,6 +53,10 @@ const tui = async (api, options) => {
     let refreshTimer;
     let pollTimer;
     let liveTimer;
+    let bandTimer;
+    const suggested = new Set();
+    const suggestedDays = new Map();
+    const colorAllowed = rainbowAllowed(motionEnabled, process.env.NO_COLOR);
     const state = () => api.state;
     const palette = () => paletteFromTheme(api.theme.current, api.theme.mode());
     // OpenCode keeps the sidebar choice in its KV store under "sidebar" ("auto" or "hide"); a child
@@ -64,6 +71,30 @@ const tui = async (api, options) => {
         const session = api.state.session.get(sessionID);
         return typeof session?.parentID === "string" && session.parentID !== "";
     }
+    // lit-adhd plays the rainbow and a working lane without a real total plays a pulse; both step at 4 Hz
+    // and only while they are on screen, and neither runs under reduced motion or NO_COLOR.
+    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() {
+        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 || chipShimmer(entry.chipMotion, now) !== undefined)
@@ -103,16 +134,48 @@ const tui = async (api, options) => {
             .notify({ title: "🔥 LIT complete", message: notice.message, notification: notify.desktop, sound: notify.sound ? { name: "done" } : false })
             .catch(() => undefined);
     }
+    // The card keeps the tallest lane count it reached while lanes are live or a turn runs, and drops back to
+    // four rows only once everything has settled, so the prompt does not jump between repaints.
+    function holdRows(held, rows, busy) {
+        if (rows > 0)
+            return Math.max(held, rows);
+        return busy ? held : 0;
+    }
+    // One toast per session, for a fresh root session in a workspace that has earlier work to pick up.
+    function suggestAdhd(sessionID) {
+        if (suggested.has(sessionID) || isChildSession(sessionID))
+            return;
+        suggested.add(sessionID);
+        const source = state();
+        const created = api.state.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 root = missionProjectRoot(source.path);
+        if (root === undefined || !hasEarlierWork(root, sessionID, now, earlierWorkWindowMs) || !adhdSuggestDue(suggestedDays, root, now))
+            return;
+        api.ui.toast({ variant: "info", title: "🔥 LIT", message: "Earlier work here. Say lit adhd to pick up where you left off.", duration: toastMs });
+    }
     function refresh(sessionID) {
         const now = Date.now();
         const source = state();
         const root = missionProjectRoot(source.path);
         const ledger = readLedger(root);
-        const next = buildMissionView(readMissionInput(source, sessionID, ledger, now, { work: readWork(root, sessionID), research: readLatestResearchRun(root) }));
-        const card = readCardInput(source, sessionID);
+        const work = readWork(root, sessionID);
+        const next = buildMissionView(readMissionInput(source, sessionID, ledger, now, { work, research: readLatestResearchRun(root) }));
+        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 entry = sessions.get(sessionID);
         const viewChanged = entry === undefined || JSON.stringify(entry.view) !== JSON.stringify(next);
-        if (!viewChanged && JSON.stringify(entry.card) === JSON.stringify(card))
+        const rainbowSeen = rainbowActive(next, card.chips, card.busy) ? now : entry?.rainbowSeen;
+        const waiting = waitingOnYou(next, card.busy, { asked: card.asked === true, userSpokeLast: card.userSpokeLast === true, blockedReply: card.blockedReply === true, boundary: work?.boundary === true });
+        const promptMoved = entry?.lastPromptAt !== times.lastPromptAt;
+        if (!viewChanged && !promptMoved && JSON.stringify(entry.card) === JSON.stringify(card) && entry.rainbowSeen === rainbowSeen && entry.waiting === waiting)
             return;
         if (entry !== undefined && viewChanged) {
             const notices = missionNotices(entry.view, next);
@@ -127,12 +190,17 @@ const tui = async (api, options) => {
             view: next,
             card,
             motion: viewChanged ? planMotion(entry?.view, next, now, entry?.motion ?? idleMotion, motionEnabled) : entry.motion,
-            chipMotion: planChipMotion(entry?.card.chips, card.chips, now, entry?.chipMotion ?? idleChipMotion, motionEnabled)
+            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
         });
         setClock(now);
         setRevision(revision() + 1);
         ensureFrames();
         syncLiveTick();
+        syncBandTimer();
     }
     function refreshTracked() {
         refreshTimer = undefined;
@@ -143,7 +211,7 @@ const tui = async (api, options) => {
     // Ledger writes from a terminal or another session fire no TUI event, so an active mission
     // re-reads goals.json (one lstat while unchanged) every two seconds. Idle sessions do not poll.
     function syncPoll() {
-        const active = [...sessions.values()].some((entry) => entry.view.active);
+        const active = [...sessions.values()].some((entry) => entry.view.active || entry.card.threads !== undefined);
         if (active && pollTimer === undefined)
             pollTimer = setInterval(refreshTracked, ledgerPollMs);
         if (!active && pollTimer !== undefined) {
@@ -164,6 +232,7 @@ const tui = async (api, options) => {
         queueMicrotask(() => {
             refresh(sessionID);
             syncPoll();
+            suggestAdhd(sessionID);
         });
     }
     // Opening a session loads its messages and parts over HTTP, which fires no bus event. Reading the
@@ -209,6 +278,8 @@ const tui = async (api, options) => {
             clearInterval(pollTimer);
         if (liveTimer !== undefined)
             clearInterval(liveTimer);
+        if (bandTimer !== undefined)
+            clearInterval(bandTimer);
         sessions.clear();
     });
     api.slots.register({
@@ -322,6 +393,13 @@ const tui = async (api, options) => {
                                     frame: snapshot.frame,
                                     chips: snapshot.card.chips,
                                     busy: snapshot.card.busy,
+                                    motion: motionEnabled,
+                                    reserve: snapshot.reserve,
+                                    ...(snapshot.card.threads === undefined ? {} : { threads: snapshot.card.threads }),
+                                    ...(snapshot.card.earlier === true ? { earlier: true } : {}),
+                                    ...(snapshot.waiting ? { turn: { glow: turnGlow(snapshot.now, colorAllowed) } } : {}),
+                                    ...(rainbowOn(snapshot, snapshot.now) ? { rainbow: rainbowAt(snapshot.now) } : {}),
+                                    ...(snapshot.card.lanes !== undefined && activeSkillLook(snapshot.view, snapshot.card.chips, snapshot.card.busy) === "review" ? { lanes: snapshot.card.lanes } : {}),
                                     ...(shimmer === undefined ? {} : { shimmer }),
                                     figures: { contextPercent: snapshot.card.contextPercent, ...(snapshot.card.branch === undefined ? {} : { branch: snapshot.card.branch }), inLane: snapshot.inLane },
                                     ...(last === undefined ? {} : { last })

package/dist/uiux-visual-catalog.js

@@ -1,7 +1,7 @@
 export const frontendUiUxFeature = {
     id: "frontend-ui-ux",
     title: "Frontend UI/UX",
-    summary: "Builds and inspects authorized interfaces using an evolving beta2 contract and offline design intelligence.",
+    summary: "Builds and inspects authorized interfaces using an evolving beta2 contract, offline design intelligence and a locked house style with a rich default.",
     bindings: [
         {
             kind: "config",
@@ -15,6 +15,12 @@ export const frontendUiUxFeature = {
             surface: "OpenCode native skill frontend-ui-ux",
             description: "Ships focused contract references plus an exact verified 167-file canonical design library. The canonical route is inert and separate from the normalized retrieval dataset."
         },
+        {
+            kind: "config",
+            id: "skills/frontend-ui-ux/kit",
+            surface: "OpenCode native skill frontend-ui-ux",
+            description: "Ships five house styles, the token-only component sheet and three layout starters; scripts/design-lock.mjs writes the design lock, tokens and fonts into a new project, and the probe checks the rendered page against it (DS-001 to DS-008)."
+        },
         {
             kind: "cli",
             id: "litopencode install",
@@ -29,6 +35,7 @@ export const frontendUiUxFeature = {
         }
     ],
     verification: [
+        "node --test test/frontend-design-lock.test.mjs",
         "node --test --test-name-pattern='uiux\\.' test/runtime-skills.test.mjs test/packed-artifact.test.mjs",
         "node --test --test-name-pattern='integration\\.installed-nested-assets' test/cli-install-surface.test.mjs",
         "npm run check:managed-skill-manifest",