@litfamily/litopencode 1.0.31 → 1.0.33

package/dist/tui/mission-band.js

@@ -5,6 +5,9 @@
 // the band always move together.
 import { ease, mixHex, motionTiming, seg } from "./mission-motion.js";
 import { contextWarnPercent, currentStepIndex, missionStatus, stepName } from "./mission-model.js";
+import { laneColor, reviewLanes, reviewMark, turnColor, turnMark } from "./mission-looks.js";
+import { isRainbowSkill, rainbowColor, rainbowPill, rainbowText, rewindMark } from "./mission-rainbow.js";
+import { threadLines } from "./mission-threads.js";
 import { cellWidth, chipSparkCells, chipSparkWidth, crumb, fade, lineWidth, linkColor, liveSegments, missionPanel, progressBar, shimmerAt, shine, stageFlash, statusSegments, truncateCells } from "./mission-text.js";
 /**
  * Reads the band switches from the plugin's tui.json options: `band: false` turns the band off,
@@ -34,6 +37,7 @@ export function readNotifyOptions(options) {
     return { enabled: desktop || sound, desktop, sound };
 }
 const minimumText = 12;
+const idleHint = "lit adhd to pick up where you left off";
 function elapsedText(minutes) {
     const total = Math.max(0, minutes ?? 0);
     return total < 60 ? `${total}m` : `${Math.floor(total / 60)}h${String(total % 60).padStart(2, "0")}`;
@@ -129,10 +133,10 @@ function phaseLabel(view, frame, palette, rest) {
         return { text: `⚑ ${status.text}`, fg: mixHex(palette.info, palette.warning, Math.max(frame.warn, 0.5)), bold: true };
     return { text: `● ${stepName(view.phase, view).toUpperCase()}`, fg: palette.info, bold: true };
 }
-function topLine(view, frame, palette, width, border, rest) {
+function topLine(view, frame, palette, width, border, rest, mark) {
     const brand = [{ text: "🔥 ", fg: palette.text }, { text: "LIT", fg: shine(palette.secondary, palette, 0.5, shimmerAt(frame), 0.6), bold: true }];
     const name = view.active ? view.discipline : "ready";
-    const right = [phaseLabel(view, frame, palette, rest)];
+    const right = mark ?? [phaseLabel(view, frame, palette, rest)];
     const withName = (room) => [...brand, { text: " · ", fg: palette.muted }, { text: truncateCells(name, room), fg: view.active ? palette.text : palette.muted }];
     const nameRoom = width - cellWidth("╭─") - lineWidth(withName(0)) - 2 - (lineWidth(right) + 2) - cellWidth("─╮") - 1;
     const attempts = [];
@@ -149,6 +153,8 @@ function topLine(view, frame, palette, width, border, rest) {
 /** The figures in the bottom border, most important first; the last ones go first when room runs out. */
 function figureParts(view, figures, palette) {
     const parts = [];
+    if (figures.restartTo !== undefined)
+        parts.push({ text: `restart to ${truncateCells(figures.restartTo, 16)}`, fg: palette.warning });
     if (figures.contextPercent !== null) {
         const percent = Math.round(figures.contextPercent);
         parts.push({ text: `ctx ${percent}%`, fg: percent >= contextWarnPercent ? palette.warning : palette.muted });
@@ -190,12 +196,16 @@ function trackPills(view, frame, palette, tight) {
     return out;
 }
 /** The text after the track in an idle session: the project's last goal, or how to start. */
-function idleText(last, palette, room) {
-    if (last === undefined || last.title === "")
-        return [{ text: "  ", fg: palette.muted }, { text: truncateCells("add lit to a prompt to start", room - 2), fg: palette.muted }];
+function idleText(last, palette, room, earlier) {
+    if (last === undefined || last.title === "") {
+        return [{ text: "  ", fg: palette.muted }, { text: truncateCells(earlier ? idleHint : "add lit to a prompt to start", room - 2), fg: earlier ? palette.accent : palette.muted }];
+    }
     const mark = last.complete ? { text: ` ✓ ${last.passed}/${last.total}`, fg: palette.success } : { text: ` ● ${last.passed}/${last.total}`, fg: palette.info };
     const head = { text: "  last: ", fg: palette.muted };
-    return [head, { text: truncateCells(last.title, room - cellWidth(head.text) - cellWidth(mark.text)), fg: palette.text }, mark];
+    const hint = earlier ? [{ text: `  ${idleHint}`, fg: palette.accent }] : [];
+    const fixed = cellWidth(head.text) + cellWidth(mark.text);
+    const withHint = hint.length > 0 && room - fixed - lineWidth(hint) >= 12 ? hint : [];
+    return [head, { text: truncateCells(last.title, room - fixed - lineWidth(withHint)), fg: palette.text }, mark, ...withHint];
 }
 // Shedding order as the row narrows: the next-task text, bar width, the bar, the criteria count and
 // then the step labels. Each plan is tried in turn and the first that fits wins.
@@ -207,7 +217,7 @@ const trackPlans = [
     { tight: false, bar: 0, criteria: false, text: false },
     { tight: true, bar: 0, criteria: false, text: false }
 ];
-function trackRow(view, frame, palette, width, last) {
+function trackRow(view, frame, palette, width, last, earlier) {
     const sweep = shimmerAt(frame);
     const gap = { text: "  ", fg: palette.muted };
     for (const plan of trackPlans) {
@@ -220,7 +230,7 @@ function trackRow(view, frame, palette, width, last) {
         if (fixed > width)
             continue;
         const room = width - fixed;
-        const after = plan.text ? (view.active ? trailing(view, frame, palette, room) : idleText(last, palette, room)) : [];
+        const after = plan.text ? (view.active ? trailing(view, frame, palette, room) : idleText(last, palette, room, earlier)) : [];
         const keepText = plan.text && after.length > 0 && (view.complete ? lineWidth(after) <= room : room >= minimumText);
         if (plan.text && after.length > 0 && !keepText)
             continue;
@@ -231,8 +241,10 @@ function trackRow(view, frame, palette, width, last) {
     }
     return fitLine(trackPills(view, frame, palette, true), width, palette);
 }
-function chipSegments(chip, shimmer, palette) {
+function chipSegments(chip, shimmer, palette, rainbow) {
     const text = ` ${chip.name} `;
+    if (rainbow !== undefined && chip.current && isRainbowSkill(chip.name))
+        return rainbowPill(text, rainbow, 180);
     if (!chip.current)
         return [{ text, fg: palette.muted, ...(palette.element === undefined ? {} : { bg: palette.element }) }];
     const sweep = shimmer?.names.includes(chip.name) === true ? shimmer.sweep : -1;
@@ -245,11 +257,11 @@ function chipSegments(chip, shimmer, palette) {
  * The skill chips row, exactly `width` cells: bright LIT accent pills for the current request first, then
  * dim recent names, and `+N` for the ones that do not fit. The label goes before any chip does.
  */
-export function skillRow(chips, shimmer, palette, width) {
+export function skillRow(chips, shimmer, palette, width, rainbow) {
     const label = { text: "skills ", fg: palette.muted };
     if (chips.length === 0)
         return fitLine([label, { text: " none yet", fg: palette.muted }], width, palette);
-    const pills = chips.map((chip) => chipSegments(chip, shimmer, palette));
+    const pills = chips.map((chip) => chipSegments(chip, shimmer, palette, rainbow));
     const space = { text: " ", fg: palette.muted };
     for (const lead of [[label], []]) {
         const all = lineWidth(lead) + pills.reduce((total, pill, index) => total + lineWidth(pill) + (index === 0 ? 0 : 1), 0);
@@ -275,6 +287,24 @@ export function skillRow(chips, shimmer, palette, width) {
     }
     return fitLine([{ text: `+${pills.length}`, fg: palette.muted }], width, palette);
 }
+/** The longest run of rule in the top border, split into the five review lanes, each in its lane's colour. */
+function laneRule(top, reports, palette) {
+    let at = -1;
+    top.forEach((segment, index) => {
+        if (/^─+$/u.test(segment.text) && (at < 0 || segment.text.length > (top[at]?.text.length ?? 0)))
+            at = index;
+    });
+    const rule = top[at];
+    if (rule === undefined || rule.text.length < reviewLanes.length)
+        return top;
+    const size = rule.text.length;
+    const parts = reviewLanes.map((lane, index) => {
+        const from = Math.floor((index * size) / reviewLanes.length);
+        const to = Math.floor(((index + 1) * size) / reviewLanes.length);
+        return { text: "─".repeat(to - from), fg: laneColor(lane, reports, palette), ...(reports[lane] === undefined ? {} : { bold: true }) };
+    });
+    return [...top.slice(0, at), ...parts, ...top.slice(at + 1)];
+}
 /**
  * The status card: four rows of exactly `width` cells whether the session is idle or working, so
  * the prompt never moves. Each row sheds its own low-priority parts as the terminal narrows.
@@ -284,14 +314,43 @@ export function statusCard(input, palette, width) {
     const rest = resting(input.view, input.busy);
     // At rest the track keeps what is done and unlights the step that was running.
     const view = rest ? { ...input.view, steps: input.view.steps.map((step) => (step.state === "now" ? { ...step, state: "todo" } : step)) } : input.view;
-    const border = borderColor(view, frame, palette, rest);
+    // One look at a time: waiting on the user first, then the rewind look, then the review lanes.
+    const turn = input.turn;
+    const rainbow = turn === undefined ? input.rainbow : undefined;
+    const lanes = turn === undefined && rainbow === undefined ? input.lanes : undefined;
+    const border = turn !== undefined ? turnColor(palette, turn.glow) : rainbow === undefined ? borderColor(view, frame, palette, rest) : rainbowColor(rainbow.hue);
+    const trackPalette = rainbow === undefined ? palette : { ...palette, primary: rainbowColor(rainbow.hue + 40), accent: rainbowColor(rainbow.hue + 160) };
     const inner = width - 4;
     const row = (content) => (inner < 0 ? fitLine([], width, palette) : [{ text: "│ ", fg: border }, ...fitLine(content, inner, palette), { text: " │", fg: border }]);
+    const mark = turn !== undefined ? turnMark(palette, turn.glow) : rainbow !== undefined ? rewindMark(rainbow) : lanes !== undefined ? reviewMark(lanes, palette) : undefined;
+    const ruledTop = topLine(view, frame, palette, width, border, rest, mark);
+    const top = lanes === undefined ? ruledTop : laneRule(ruledTop, lanes, palette);
+    const threadRows = input.threads === undefined ? [] : threadLines(input.threads, palette, Math.max(0, inner), {
+        now: frame.now ?? 0,
+        motion: input.motion ?? true,
+        ...(rainbow === undefined ? {} : { gaugeColor: (index) => rainbowColor(rainbow.hue + 60 + index * 50) })
+    });
+    while (threadRows.length < (input.reserve ?? 0))
+        threadRows.push([]);
+    const track = trackRow(view, frame, trackPalette, Math.max(0, inner), input.last, input.earlier === true);
+    const bottom = bottomLine(view, input.figures, palette, width, border);
+    if (rainbow === undefined)
+        return [top, row(track), row(skillRow(input.chips, input.shimmer, palette, Math.max(0, inner))), ...threadRows.map(row), bottom];
+    // The rewind look reaches every pill cell by cell: LIT, the running phase, the lit-adhd chip; the phase
+    // labels and the context figure turn on the card's own ground.
+    const names = view.steps.map((step) => stepName(step.id, view).toLowerCase());
+    const label = (text) => names.findIndex((name) => text.trim().toLowerCase().startsWith(name));
     return [
-        topLine(view, frame, palette, width, border, rest),
-        row(trackRow(view, frame, palette, Math.max(0, inner), input.last)),
-        row(skillRow(input.chips, input.shimmer, palette, Math.max(0, inner))),
-        bottomLine(view, input.figures, palette, width, border)
+        top.flatMap((segment) => (segment.text === "LIT" ? rainbowPill("LIT", rainbow, 90) : [segment])),
+        row(track.flatMap((segment) => {
+            if (segment.bg !== undefined && segment.bold === true && /\S/u.test(segment.text))
+                return rainbowPill(segment.text, rainbow, 160);
+            const at = segment.bg === undefined ? label(segment.text) : -1;
+            return at >= 0 ? [{ ...segment, fg: rainbowColor(rainbow.hue + 200 + at * 50), bold: true }] : [segment];
+        })),
+        row(skillRow(input.chips, input.shimmer, palette, Math.max(0, inner), rainbow)),
+        ...threadRows.map(row),
+        bottom.flatMap((segment) => (segment.text.startsWith("ctx ") ? rainbowText(segment.text, rainbow, 120) : [segment]))
     ];
 }
 const cardRows = 4;

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

@@ -0,0 +1,38 @@
+import type { MissionPalette, Segment } from "./mission-text.ts";
+import type { MissionView } from "./mission-model.ts";
+import type { SkillChip } from "./mission-skills.ts";
+export type SkillLook = "rewind" | "review";
+/** The look a skill name carries, if any. */
+export declare function lookOfSkill(name: string): SkillLook | undefined;
+/** The skill look while a turn runs: the session's discipline first, then a chip this turn lit. */
+export declare function activeSkillLook(view: Pick<MissionView, "active" | "discipline">, chips: readonly SkillChip[], busy: boolean | undefined): SkillLook | undefined;
+/** What the session is waiting on the user for, read from records; every field is a real signal. */
+export type WaitSignals = {
+    /** OpenCode holds a permission request or a question for this session. */
+    readonly asked: boolean;
+    /** The last message is the user's: they have answered, so nothing waits on them now. */
+    readonly userSpokeLast: boolean;
+    /** The last reply of the turn opens with `BLOCKED:`. */
+    readonly blockedReply: boolean;
+    /** A typed start-work run is paused on a boundary only the user can approve. */
+    readonly boundary: boolean;
+};
+/** True while the session waits on the user: asked now, or idle on a decision, a BLOCKED reply or a boundary. */
+export declare function waitingOnYou(view: Pick<MissionView, "active" | "warnings">, busy: boolean | undefined, signals: WaitSignals): boolean;
+export declare const turnBreathMs = 3000;
+/** How far the amber has eased toward the border at `now`, 0 to 1; a 3 s sine, 0 under reduced motion. */
+export declare function turnGlow(now: number, motion: boolean): number;
+/** The amber of the waiting look: the warning colour eased at most 25 % toward the card's border. */
+export declare function turnColor(palette: MissionPalette, glow: number): string;
+export declare function turnMark(palette: MissionPalette, glow: number): Segment[];
+export declare const reviewLanes: readonly ["scope", "tests", "package", "security", "surface"];
+export type ReviewLane = (typeof reviewLanes)[number];
+export type LaneResult = "pass" | "fail" | "blocked";
+export type LaneReports = Partial<Readonly<Record<ReviewLane, LaneResult>>>;
+export declare const laneResults: readonly LaneResult[];
+export declare function isReviewLane(value: unknown): value is ReviewLane;
+export declare function isLaneResult(value: unknown): value is LaneResult;
+/** One lane's colour on the border: its own hue once it reports a pass, error once it fails, dim until then. */
+export declare function laneColor(lane: ReviewLane, reports: LaneReports, palette: MissionPalette): string;
+/** The corner label of the review look: how many of the five lanes have reported, never a guess. */
+export declare function reviewMark(reports: LaneReports, palette: MissionPalette): Segment[];

package/dist/tui/mission-looks.js

@@ -0,0 +1,73 @@
+// The looks the status card can wear, chosen in one place. A skill look belongs to the discipline at work
+// or to a chip lit by this turn: lit-adhd and its alias lit-rewind wear the rewind look, review-work wears
+// its five lanes. A state look belongs to the session: `YOUR TURN` while it waits on the user, and the
+// done burst (the completion sparks of mission-motion) when a goal reaches done. Each look reads only
+// records OpenCode or LitOpenCode already keep, so a lane without a report stays dim and nothing is
+// guessed. Motion is slow and small: the amber breath is one hue held while its mix eases over 3 s.
+import { mixHex } from "./mission-motion.js";
+const skillLooks = Object.freeze({ "lit-adhd": "rewind", "lit-rewind": "rewind", "review-work": "review" });
+/** The look a skill name carries, if any. */
+export function lookOfSkill(name) {
+    return Object.hasOwn(skillLooks, name) ? skillLooks[name] : undefined;
+}
+/** The skill look while a turn runs: the session's discipline first, then a chip this turn lit. */
+export function activeSkillLook(view, chips, busy) {
+    if (busy === false)
+        return undefined;
+    const own = view.active ? lookOfSkill(view.discipline) : undefined;
+    if (own !== undefined)
+        return own;
+    for (const chip of chips) {
+        const look = chip.current ? lookOfSkill(chip.name) : undefined;
+        if (look !== undefined)
+            return look;
+    }
+    return undefined;
+}
+/** True while the session waits on the user: asked now, or idle on a decision, a BLOCKED reply or a boundary. */
+export function waitingOnYou(view, busy, signals) {
+    if (signals.asked)
+        return true;
+    if (signals.userSpokeLast || busy === true)
+        return false;
+    const decision = view.active && view.warnings.some((warning) => warning.kind === "decision");
+    return decision || signals.blockedReply || signals.boundary;
+}
+export const turnBreathMs = 3000;
+/** How far the amber has eased toward the border at `now`, 0 to 1; a 3 s sine, 0 under reduced motion. */
+export function turnGlow(now, motion) {
+    if (!motion)
+        return 0;
+    return (1 - Math.cos((2 * Math.PI * (now % turnBreathMs)) / turnBreathMs)) / 2;
+}
+/** The amber of the waiting look: the warning colour eased at most 25 % toward the card's border. */
+export function turnColor(palette, glow) {
+    return mixHex(palette.warning, palette.borderActive, Math.min(1, Math.max(0, glow)) * 0.25);
+}
+export function turnMark(palette, glow) {
+    return [{ text: "◆ YOUR TURN", fg: turnColor(palette, glow), bold: true }];
+}
+export const reviewLanes = ["scope", "tests", "package", "security", "surface"];
+export const laneResults = ["pass", "fail", "blocked"];
+export function isReviewLane(value) {
+    return typeof value === "string" && reviewLanes.includes(value);
+}
+export function isLaneResult(value) {
+    return typeof value === "string" && laneResults.includes(value);
+}
+/** One lane's colour on the border: its own hue once it reports a pass, error once it fails, dim until then. */
+export function laneColor(lane, reports, palette) {
+    const result = reports[lane];
+    if (result === undefined)
+        return palette.borderSubtle;
+    if (result !== "pass")
+        return palette.error;
+    const hues = [palette.primary, palette.info, palette.accent, palette.secondary, palette.success];
+    return hues[reviewLanes.indexOf(lane)] ?? palette.success;
+}
+/** The corner label of the review look: how many of the five lanes have reported, never a guess. */
+export function reviewMark(reports, palette) {
+    const reported = reviewLanes.filter((lane) => reports[lane] !== undefined).length;
+    const failed = reviewLanes.some((lane) => reports[lane] !== undefined && reports[lane] !== "pass");
+    return [{ text: `◇ REVIEW ${reported}/${reviewLanes.length}`, fg: failed ? palette.error : palette.info, bold: true }];
+}

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

@@ -20,6 +20,7 @@ export type WorkInput = {
     readonly status: string;
     readonly iterations: number;
     readonly plan?: PlanChecklist;
+    readonly boundary?: boolean;
 };
 export type ResearchStage = "decompose" | "wave" | "expand" | "verify" | "synthesis";
 /** The latest litresearch run folder: what its journal, claim graph and report say so far. */
@@ -143,6 +144,7 @@ export declare function readWorkState(raw: unknown, sessionID: string): {
     readonly status: string;
     readonly iterations: number;
     readonly planPath: string;
+    readonly boundary?: true;
 } | undefined;
 type LedgerCriterion = {
     readonly id: string;

package/dist/tui/mission-model.js

@@ -109,7 +109,9 @@ export function readWorkState(raw, sessionID) {
         return undefined;
     const history = Array.isArray(raw.history) ? raw.history.filter(isRecord) : [];
     const plan = isRecord(raw.plan) ? text(raw.plan.path) : "";
-    return { status, iterations: history.filter((entry) => entry.type === "work.progressed").length, planPath: plan };
+    // A paused run holding a boundary waits for the user's typed approval.
+    const boundary = status === "paused" && isRecord(raw.pendingBoundary);
+    return { status, iterations: history.filter((entry) => entry.type === "work.progressed").length, planPath: plan, ...(boundary ? { boundary: true } : {}) };
 }
 // The ledger CLI accepts `passed`, `failed` and `completed` as spellings of its own statuses; a goals.json
 // the agent writes by hand also marks a finished criterion `completed` or `done`.

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

@@ -0,0 +1,33 @@
+import type { SkillChip } from "./mission-skills.ts";
+import type { Line, Segment } from "./mission-text.ts";
+import type { MissionView } from "./mission-model.ts";
+export declare const rainbowTickMs = 250;
+export type Rainbow = {
+    readonly hue: number;
+};
+/** True while the session's current discipline or a chip lit by this turn is lit-adhd or lit-rewind. */
+export declare function rainbowActive(view: Pick<MissionView, "active" | "discipline">, chips: readonly SkillChip[], busy: boolean | undefined): boolean;
+/** The rewind look outlasts its turn so the band stays lit while the user reads the brief. */
+export declare const rainbowLingerMs: number;
+/** Shown while lit-adhd runs, then until the next prompt, for at most rainbowLingerMs after it was last seen. */
+export declare function rainbowShows(active: boolean, seenAt: number | undefined, lastPromptAt: number | undefined, now: number): boolean;
+/** The top-border mark of the rewind look: REWIND « with a hue per letter, then a four-cell sparkle trail. */
+export declare function rewindMark(rainbow: Rainbow): Line;
+/** True for the skill names that carry the rewind look. */
+export declare const isRainbowSkill: (name: string) => boolean;
+/** A pill cell's fill at this hue: the rainbow colour lifted toward white, so the dark ink keeps 4.5:1. */
+export declare function rainbowCell(hue: number): string;
+/**
+ * A pill drawn cell by cell through the rainbow: each cell a step further round the wheel, dark bold ink
+ * on top. Only the colours of fixed cells move, so the text and width never change and nothing flashes.
+ */
+export declare function rainbowPill(text: string, rainbow: Rainbow, offset: number): Segment[];
+/** Plain text with each character a step round the wheel, for labels that sit on the card's ground. */
+export declare function rainbowText(text: string, rainbow: Rainbow, offset: number): Segment[];
+/** Whether the rainbow may play at all: tui.json motion is not off and NO_COLOR is unset or empty. */
+export declare function rainbowAllowed(motion: boolean, noColor: string | undefined): boolean;
+export declare function rainbowAt(now: number): Rainbow;
+/** An OKLCH colour at the rainbow's fixed lightness and chroma, as `#rrggbb`. */
+export declare function rainbowColor(hue: number): string;
+/** WCAG relative luminance of a `#rrggbb` colour, 0 to 1. */
+export declare function relativeLuminance(hex: string): number;

package/dist/tui/mission-rainbow.js

@@ -0,0 +1,90 @@
+// The look of the band while lit-adhd (alias lit-rewind) is the discipline at work: the border, the LIT
+// word and the gauges take a colour that walks round the hue wheel. Every colour is drawn at one fixed
+// OKLCH lightness, so the brightness of the band never swings; only the hue moves, a few degrees per
+// 250 ms tick, which is four small colour steps a second and no flash at all. It is off under reduced
+// motion (tui.json `motion: false`) and NO_COLOR, and it never reaches a session that is not rewinding.
+import { activeSkillLook, lookOfSkill } from "./mission-looks.js";
+import { mixHex } from "./mission-motion.js";
+export const rainbowTickMs = 250;
+/** Degrees of hue per second: a full turn every 12 s, 7.5 degrees per tick. */
+const degreesPerSecond = 30;
+const lightness = 0.8;
+const chroma = 0.115;
+/** True while the session's current discipline or a chip lit by this turn is lit-adhd or lit-rewind. */
+export function rainbowActive(view, chips, busy) {
+    return activeSkillLook(view, chips, busy) === "rewind";
+}
+/** The rewind look outlasts its turn so the band stays lit while the user reads the brief. */
+export const rainbowLingerMs = 15 * 60_000;
+/** Shown while lit-adhd runs, then until the next prompt, for at most rainbowLingerMs after it was last seen. */
+export function rainbowShows(active, seenAt, lastPromptAt, now) {
+    if (active)
+        return true;
+    if (seenAt === undefined || now - seenAt > rainbowLingerMs)
+        return false;
+    return lastPromptAt === undefined || lastPromptAt <= seenAt;
+}
+const sparkleFrames = ["✦·⋆·", "·✦·⋆", "⋆·✦·", "·⋆·✧"];
+/** The top-border mark of the rewind look: REWIND « with a hue per letter, then a four-cell sparkle trail. */
+export function rewindMark(rainbow) {
+    const letters = [..."REWIND"].map((letter, index) => ({ text: letter, fg: rainbowColor(rainbow.hue + index * 45), bold: true }));
+    // The hue advances one step per tick, so it also clocks the trail.
+    const tick = Math.floor(rainbow.hue / ((degreesPerSecond * rainbowTickMs) / 1000));
+    const trail = sparkleFrames[tick % sparkleFrames.length] ?? sparkleFrames[0];
+    return [...letters, { text: " «", fg: rainbowColor(rainbow.hue + 270) }, { text: " ", fg: rainbowColor(rainbow.hue) }, ...[...trail].map((glyph, index) => ({ text: glyph, fg: rainbowColor(rainbow.hue + 300 + index * 20) }))];
+}
+/** True for the skill names that carry the rewind look. */
+export const isRainbowSkill = (name) => lookOfSkill(name) === "rewind";
+/** Degrees of hue one pill spans from its first cell to its last. */
+const pillSpread = 126;
+const pillInk = "#14161c";
+/** A pill cell's fill at this hue: the rainbow colour lifted toward white, so the dark ink keeps 4.5:1. */
+export function rainbowCell(hue) {
+    return mixHex(rainbowColor(hue), "#ffffff", 0.3);
+}
+/**
+ * A pill drawn cell by cell through the rainbow: each cell a step further round the wheel, dark bold ink
+ * on top. Only the colours of fixed cells move, so the text and width never change and nothing flashes.
+ */
+export function rainbowPill(text, rainbow, offset) {
+    const chars = [...text];
+    const step = chars.length <= 1 ? 0 : pillSpread / (chars.length - 1);
+    return chars.map((char, index) => ({ text: char, fg: pillInk, bg: rainbowCell(rainbow.hue + offset + index * step), bold: true }));
+}
+/** Plain text with each character a step round the wheel, for labels that sit on the card's ground. */
+export function rainbowText(text, rainbow, offset) {
+    return [...text].map((char, index) => ({ text: char, fg: rainbowColor(rainbow.hue + offset + index * 24), bold: true }));
+}
+/** Whether the rainbow may play at all: tui.json motion is not off and NO_COLOR is unset or empty. */
+export function rainbowAllowed(motion, noColor) {
+    return motion && (noColor === undefined || noColor === "");
+}
+export function rainbowAt(now) {
+    return { hue: ((now / 1000) * degreesPerSecond) % 360 };
+}
+function encode(linear) {
+    const clamped = Math.min(1, Math.max(0, linear));
+    return clamped <= 0.0031308 ? 12.92 * clamped : 1.055 * clamped ** (1 / 2.4) - 0.055;
+}
+/** An OKLCH colour at the rainbow's fixed lightness and chroma, as `#rrggbb`. */
+export function rainbowColor(hue) {
+    const radians = (((hue % 360) + 360) % 360) * (Math.PI / 180);
+    const a = chroma * Math.cos(radians);
+    const b = chroma * Math.sin(radians);
+    const l = (lightness + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+    const m = (lightness - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+    const s = (lightness - 0.0894841775 * a - 1.291485548 * b) ** 3;
+    const red = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+    const green = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+    const blue = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+    return "#" + [red, green, blue].map((channel) => Math.round(encode(channel) * 255).toString(16).padStart(2, "0")).join("");
+}
+function linear(channel) {
+    const value = channel / 255;
+    return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+}
+/** WCAG relative luminance of a `#rrggbb` colour, 0 to 1. */
+export function relativeLuminance(hex) {
+    const channels = [1, 3, 5].map((index) => linear(Number.parseInt(hex.slice(index, index + 2), 16)));
+    return 0.2126 * channels[0] + 0.7152 * channels[1] + 0.0722 * channels[2];
+}

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

@@ -1,5 +1,7 @@
 import { type LiveStep, type MissionInput, type ResearchInput, type TodoInput, type WorkInput } from "./mission-model.ts";
+import { type LaneReports, type ReviewLane, type LaneResult } from "./mission-looks.ts";
 import { type SkillChip } from "./mission-skills.ts";
+import { type ThreadRow, type ThreadSource } from "./mission-threads.ts";
 type MessageLike = {
     readonly id: string;
     readonly role: string;
@@ -88,11 +90,58 @@ export type CardInput = {
     readonly busy: boolean;
     readonly contextPercent: number | null;
     readonly branch?: string;
+    /** Two or more lanes of work, from the stack, `task` calls and sibling sessions. */
+    readonly threads?: readonly ThreadRow[];
+    /** Another session here moved lately, so an idle card can name `lit adhd`. */
+    readonly earlier?: boolean;
+    /** The lanes review-work has reported since its latest start; present once a review ran here. */
+    readonly lanes?: LaneReports;
+    /** OpenCode holds a permission request or a question for this session. */
+    readonly asked?: boolean;
+    /** The last message is the user's. */
+    readonly userSpokeLast?: boolean;
+    /** The last reply opens with `BLOCKED:`. */
+    readonly blockedReply?: boolean;
 };
+/** A completed `review-work` call with action `lane`: one lane's reported result. */
+export declare function readLaneReport(part: unknown): {
+    readonly lane: ReviewLane;
+    readonly result: LaneResult;
+} | undefined;
+/**
+ * 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 declare function opensBlocked(parts: readonly unknown[]): boolean;
 /**
  * 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" },
  * "retry" or "idle"); a session it has not seen run has none, which counts as not running.
  */
 export declare function readCardInput(state: MissionStateSource, sessionID: string): CardInput;
+export declare const earlierWorkWindowMs: number;
+/**
+ * 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, read with their
+ * liveness records. Another session's completed start-work run shows as done. Only counts that are real
+ * totals are carried; the input of a tool call is read for its description alone.
+ */
+export declare function readThreadSources(state: MissionStateSource, sessionID: string, root: string | undefined, now: number): ThreadSource[];
+/**
+ * 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 declare function messageTimes(state: MissionStateSource, sessionID: string): {
+    readonly lastAt?: number;
+    readonly lastPromptAt?: number;
+};
+/** The way back in is offered after this long without a message in the session. */
+export declare const adhdBreakMs: number;
+/** The idle card names lit adhd in a fresh session or after a break, only when earlier work exists. */
+export declare function wayBackDue(lastActivityAt: number | undefined, now: number, earlier: boolean): boolean;
+/** At most one start suggestion per workspace per local day; records the day when it answers true. */
+export declare function adhdSuggestDue(days: Map<string, string>, root: string, now: number): boolean;
+export declare function hasEarlierWork(root: string | undefined, sessionID: string, now: number, withinMs: number): boolean;
 export {};