@litfamily/litopencode 1.0.19 → 1.0.21

package/dist/model-route-policy.js

@@ -1,8 +1,14 @@
 import { effectiveAgentConfig } from "./config.js";
-import { defaultOpenAiRoutes, newGenerationOpenAiModels, openAiModelEfforts, previousGenerationOpenAiModels, previousGpt6OpenAiModels, stripFastSuffix } from "./cli/model-catalog.js";
-const safeLunaEfforts = new Set(openAiModelEfforts(previousGenerationOpenAiModels.luna));
-const safeTerraEfforts = new Set(openAiModelEfforts(previousGenerationOpenAiModels.terra));
+import { defaultOpenAiRoutes, newGenerationOpenAiModels, openAiModelEfforts, previousGenerationOpenAiModels, previousGpt6OpenAiModels, replacedRetiredEffort, stripFastSuffix } from "./cli/model-catalog.js";
 const safeAstraEfforts = new Set(openAiModelEfforts(defaultOpenAiRoutes.lead.model));
+// The managed rows whose effort is checked; other GPT-5.6 ids stay user-owned as before.
+const guardedModels = new Set([
+    newGenerationOpenAiModels.sol,
+    previousGpt6OpenAiModels.sol,
+    newGenerationOpenAiModels.luna,
+    previousGenerationOpenAiModels.luna,
+    previousGenerationOpenAiModels.terra
+]);
 function dispatchedModel(route) {
     if (route.model === undefined)
         return undefined;
@@ -53,41 +59,17 @@ export function diagnoseModelRoutes(routes) {
             }
             continue;
         }
-        if (modelId === newGenerationOpenAiModels.sol || modelId === previousGpt6OpenAiModels.sol || modelId === newGenerationOpenAiModels.luna) {
-            const supported = new Set(openAiModelEfforts(modelId));
-            const variantUnsafe = route.variant !== undefined && !supported.has(route.variant);
-            const reasoningUnsafe = route.reasoningEffort !== undefined && !supported.has(route.reasoningEffort);
-            if (variantUnsafe || reasoningUnsafe || (route.variant === undefined && route.reasoningEffort === undefined)) {
-                diagnostics.push({ agentId, code: "model_effort_unsupported", model, effort });
-            }
-            if (route.variant !== undefined && route.reasoningEffort !== undefined && route.variant !== route.reasoningEffort) {
-                diagnostics.push({ agentId, code: "model_effort_conflict", model, effort });
-            }
-            continue;
-        }
-        if (modelId === previousGenerationOpenAiModels.luna) {
-            const hasXhigh = route.variant === "xhigh" || route.reasoningEffort === "xhigh";
-            if ((route.variant !== undefined && route.variant !== "xhigh" && !safeLunaEfforts.has(route.variant)) ||
-                (route.reasoningEffort !== undefined && route.reasoningEffort !== "xhigh" && !safeLunaEfforts.has(route.reasoningEffort)) ||
-                (route.variant === undefined && route.reasoningEffort === undefined)) {
-                diagnostics.push({ agentId, code: "luna_effort_below_high", model, effort });
-            }
-            if (hasXhigh)
-                diagnostics.push({ agentId, code: "luna_xhigh_forbidden", model, effort });
-            if (route.variant !== undefined && route.reasoningEffort !== undefined && route.variant !== route.reasoningEffort) {
-                diagnostics.push({ agentId, code: "luna_effort_conflict", model, effort });
-            }
+        // Each guarded row accepts exactly the efforts OpenCode offers for it.
+        if (!guardedModels.has(modelId))
             continue;
-        }
-        if (modelId !== previousGenerationOpenAiModels.terra)
-            continue;
-        if ((route.variant !== undefined && !safeTerraEfforts.has(route.variant)) ||
-            (route.reasoningEffort !== undefined && !safeTerraEfforts.has(route.reasoningEffort)) ||
-            (route.variant === undefined && route.reasoningEffort === undefined)) {
-            diagnostics.push({ agentId, code: "terra_effort_below_high", model, effort });
+        const supported = new Set(openAiModelEfforts(modelId));
+        const variantUnsafe = route.variant !== undefined && !supported.has(route.variant);
+        const reasoningUnsafe = route.reasoningEffort !== undefined && !supported.has(route.reasoningEffort);
+        if (variantUnsafe || reasoningUnsafe || (route.variant === undefined && route.reasoningEffort === undefined)) {
+            diagnostics.push({ agentId, code: "model_effort_unsupported", model, effort });
         }
         if (route.variant !== undefined && route.reasoningEffort !== undefined && route.variant !== route.reasoningEffort) {
-            diagnostics.push({ agentId, code: "terra_effort_conflict", model, effort });
+            diagnostics.push({ agentId, code: "model_effort_conflict", model, effort });
         }
     }
     return diagnostics;
@@ -114,22 +96,12 @@ export class UnsafeModelRouteError extends Error {
         const summary = diagnostics
             .map((diagnostic) => {
             switch (diagnostic.code) {
-                case "luna_effort_below_high":
-                    return `${diagnostic.agentId}: Luna requires high or max (${diagnostic.model}, ${diagnostic.effort})`;
-                case "luna_xhigh_forbidden":
-                    return `${diagnostic.agentId}: Luna plus xhigh is forbidden (${diagnostic.model}, ${diagnostic.effort})`;
-                case "luna_effort_conflict":
-                    return `${diagnostic.agentId}: Luna effort fields conflict (${diagnostic.model}, ${diagnostic.effort})`;
-                case "terra_effort_below_high":
-                    return `${diagnostic.agentId}: TERRA requires high or xhigh (${diagnostic.model}, ${diagnostic.effort})`;
-                case "terra_effort_conflict":
-                    return `${diagnostic.agentId}: TERRA effort fields conflict (${diagnostic.model}, ${diagnostic.effort})`;
                 case "astra_effort_unsupported":
-                    return `${diagnostic.agentId}: Astra requires low, medium, high, xhigh, or max (${diagnostic.model}, ${diagnostic.effort})`;
+                    return `${diagnostic.agentId}: Astra requires ${[...safeAstraEfforts].join(", ")} (${diagnostic.model}, ${diagnostic.effort})`;
                 case "astra_effort_conflict":
                     return `${diagnostic.agentId}: Astra effort fields conflict (${diagnostic.model}, ${diagnostic.effort})`;
                 case "model_effort_unsupported":
-                    return `${diagnostic.agentId}: ${diagnostic.model} accepts a supported catalog effort (${diagnostic.model}, ${diagnostic.effort})`;
+                    return `${diagnostic.agentId}: ${diagnostic.model} accepts ${openAiModelEfforts(unqualifiedModel(diagnostic.model)).join(", ")} (${diagnostic.model}, ${diagnostic.effort})`;
                 case "model_effort_conflict":
                     return `${diagnostic.agentId}: ${diagnostic.model} effort fields conflict (${diagnostic.model}, ${diagnostic.effort})`;
             }
@@ -144,3 +116,30 @@ export function assertSafeEffectiveAgentRoutes(config, agentIds) {
     if (diagnostics.length > 0)
         throw new UnsafeModelRouteError(diagnostics);
 }
+function isRouteRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The saved routes in a litopencode.json object that still name an effort OpenCode no longer offers. */
+export function retiredEffortRoutes(config) {
+    const found = [];
+    if (!isRouteRecord(config))
+        return found;
+    for (const section of ["categories", "agents"]) {
+        const entries = config[section];
+        if (!isRouteRecord(entries))
+            continue;
+        for (const [id, route] of Object.entries(entries)) {
+            if (!isRouteRecord(route) || typeof route.model !== "string")
+                continue;
+            const provider = typeof route.provider === "string" ? route.provider : undefined;
+            const effort = (value) => (typeof value === "string" ? value : undefined);
+            if (replacedRetiredEffort(provider, route.model, effort(route.variant)) === undefined && replacedRetiredEffort(provider, route.model, effort(route.reasoningEffort)) === undefined)
+                continue;
+            found.push({ section, id, model: route.model.slice(route.model.indexOf("/") + 1) });
+        }
+    }
+    return found;
+}
+export function retiredEffortWarning(route) {
+    return `ultra is no longer offered by OpenCode for ${route.model} (${route.section}.${route.id}); the next install moves it to max.`;
+}

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

@@ -1,29 +1,49 @@
 import { type MotionFrame } from "./mission-motion.ts";
-import type { MissionView } from "./mission-model.ts";
-import { type Line, type MissionPalette } from "./mission-text.ts";
+import { type MissionView } from "./mission-model.ts";
+import type { ChipShimmer, SkillChip } from "./mission-skills.ts";
+import { type LastMission, type Line, type MissionPalette } from "./mission-text.ts";
 export type BandOptions = {
     readonly enabled: boolean;
     readonly card: boolean;
 };
 /**
  * Reads the band switches from the plugin's tui.json options: `band: false` turns the band off,
- * `band: { card: true }` adds the card under the ribbon. Anything else keeps the defaults.
+ * `band: { card: true }` adds the detail card under the status card. Anything else keeps the defaults.
  */
 export declare function readBandOptions(options: unknown): BandOptions;
 /**
- * One ribbon row exactly `width` cells wide: pills, bar, the next task or a warning, and the elapsed
- * time, shedding parts in a fixed order so it never wraps. Idle sessions draw nothing.
+ * The skill chips row, exactly `width` cells: bright 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 declare function bandRibbon(view: MissionView, frame: MotionFrame, palette: MissionPalette, width: number, place: {
+export declare function skillRow(chips: readonly SkillChip[], shimmer: ChipShimmer | undefined, palette: MissionPalette, width: number): Line;
+export type CardFigures = {
+    readonly contextPercent: number | null;
+    readonly branch?: string;
     readonly inLane: boolean;
-}): Line;
+};
+export type CardInputs = {
+    readonly view: MissionView;
+    readonly frame: MotionFrame;
+    readonly chips: readonly SkillChip[];
+    /** Whether the session's turn is running; false lets a lit card rest at idle. Unknown keeps it working. */
+    readonly busy?: boolean;
+    readonly shimmer?: ChipShimmer;
+    readonly figures: CardFigures;
+    /** The project's last goal, shown on the track while the session has no lit mission. */
+    readonly last?: LastMission;
+};
+/**
+ * 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.
+ */
+export declare function statusCard(input: CardInputs, palette: MissionPalette, width: number): Line[];
 export type BandCard = {
     readonly title: string;
     readonly border: string;
     readonly rows: readonly Line[];
 };
 /**
- * The opt-in card under the ribbon. It keeps a fixed four rows whenever a goal exists, warnings
+ * The opt-in detail card under the status card. It keeps a fixed four rows whenever a goal exists, warnings
  * first, so turning a warning on or off never moves the prompt.
  */
 export declare function bandCard(view: MissionView, frame: MotionFrame, palette: MissionPalette, width: number): BandCard | undefined;

package/dist/tui/mission-band.js

@@ -1,11 +1,14 @@
-// The band: one full-width ribbon row in OpenCode's app_bottom slot that carries the lit mission on
-// the main screen, plus an opt-in card. It reuses the chip's pills, the panel's bar and the shared
-// motion frame, so the chip, the panel and the band always move together.
-import { mixHex, motionTiming } from "./mission-motion.js";
-import { cellWidth, chipGroups, chipSparkCells, chipSparkWidth, groupsWidth, lineWidth, missionPanel, progressBar, shimmerAt, statusSegments, truncateCells } from "./mission-text.js";
+// The band: a status card in OpenCode's full-width app_bottom slot that stays on screen for the
+// whole session, plus an opt-in detail card. Its border carries the LIT mark, the discipline and the
+// phase; row one is the phase track, row two the skill chips, and the bottom border the live figures.
+// It reuses the chip's pills, the panel's bar and the shared motion frame, so the chip, the panel and
+// the band always move together.
+import { ease, mixHex, motionTiming, seg } from "./mission-motion.js";
+import { contextWarnPercent, missionStatus } from "./mission-model.js";
+import { cellWidth, chipSparkCells, chipSparkWidth, fade, lineWidth, missionPanel, progressBar, shimmerAt, shine, statusSegments, stepPill, truncateCells } from "./mission-text.js";
 /**
  * Reads the band switches from the plugin's tui.json options: `band: false` turns the band off,
- * `band: { card: true }` adds the card under the ribbon. Anything else keeps the defaults.
+ * `band: { card: true }` adds the detail card under the status card. Anything else keeps the defaults.
  */
 export function readBandOptions(options) {
     const band = typeof options === "object" && options !== null ? options.band : undefined;
@@ -14,18 +17,6 @@ export function readBandOptions(options) {
     const card = typeof band === "object" && band !== null && band.card === true;
     return { enabled: true, card };
 }
-// Shedding order as the row narrows: step labels first, then the next-task text, then bar width,
-// then the time. Each plan is tried in turn and the first that fits wins.
-const plans = [
-    { tier: "full", bar: 18, text: true, time: true },
-    { tier: "medium", bar: 18, text: true, time: true },
-    { tier: "tight", bar: 18, text: true, time: true },
-    { tier: "tight", bar: 18, text: false, time: true },
-    { tier: "tight", bar: 10, text: false, time: true },
-    { tier: "tight", bar: 5, text: false, time: true },
-    { tier: "tight", bar: 0, text: false, time: true },
-    { tier: "tight", bar: 0, text: false, time: false }
-];
 const minimumText = 12;
 function elapsedText(minutes) {
     const total = Math.max(0, minutes ?? 0);
@@ -50,41 +41,234 @@ function trailing(view, frame, palette, room) {
         return [];
     return [{ text: "  ▸ ", fg: palette.muted }, { text: truncateCells(view.next, room - 4), fg: palette.text }];
 }
+/** Cuts or pads a line to exactly `width` cells, keeping wide glyphs whole. */
+function fitLine(line, width, palette) {
+    const out = [];
+    let used = 0;
+    for (const segment of line) {
+        const room = width - used;
+        if (room <= 0)
+            break;
+        if (cellWidth(segment.text) <= room) {
+            out.push(segment);
+            used += cellWidth(segment.text);
+            continue;
+        }
+        let text = "";
+        let taken = 0;
+        for (const char of segment.text) {
+            const w = cellWidth(char);
+            if (taken + w > room)
+                break;
+            text += char;
+            taken += w;
+        }
+        if (text !== "")
+            out.push({ ...segment, text });
+        used += taken;
+        break;
+    }
+    if (used < width)
+        out.push({ text: " ".repeat(width - used), fg: palette.muted });
+    return out;
+}
+/** A border row: corner, optional left label, rule, optional right label, corner; undefined when it does not fit. */
+function ruled(lead, left, right, tail, width, border) {
+    const space = { text: " ", fg: border };
+    const l = left.length > 0 ? [space, ...left, space] : [];
+    const r = right.length > 0 ? [space, ...right, space] : [];
+    const fill = width - cellWidth(lead) - lineWidth(l) - lineWidth(r) - cellWidth(tail);
+    if (fill < 1)
+        return undefined;
+    return [{ text: lead, fg: border }, ...l, { text: "─".repeat(fill), fg: border }, ...r, { text: tail, fg: border }];
+}
 /**
- * One ribbon row exactly `width` cells wide: pills, bar, the next task or a warning, and the elapsed
- * time, shedding parts in a fixed order so it never wraps. Idle sessions draw nothing.
+ * A lit session whose turn has ended rests: nothing is running, so the card stops showing a lit step.
+ * A finished goal and an open warning still show, since they are news after the turn.
  */
-export function bandRibbon(view, frame, palette, width, place) {
-    if (!view.active || width <= 0)
-        return [];
-    const time = { text: `⟳ ${elapsedText(view.elapsedMinutes)}${place.inLane ? " · in lane" : ""}`, fg: palette.muted };
+function resting(view, busy) {
+    return view.active && busy === false && !view.complete && view.warnings.length === 0;
+}
+function borderColor(view, frame, palette, rest) {
+    if (!view.active || rest)
+        return palette.borderActive;
+    const enter = frame.chipEnter ? ease.outCubic(seg(frame.t, 0, motionTiming.entry)) : 1;
+    const done = view.complete ? (frame.celebrate === undefined ? 1 : ease.inOutCubic(seg(frame.celebrate, 0, motionTiming.crossfade))) : 0;
+    return mixHex(palette.borderActive, mixHex(mixHex(palette.accent, palette.warning, frame.warn), palette.success, done), enter);
+}
+/** The phase on the right of the title: always a glyph plus words. */
+function phaseLabel(view, frame, palette, rest) {
+    if (!view.active || rest)
+        return { text: "○ IDLE", fg: palette.muted };
+    const status = missionStatus(view);
+    if (status.tone === "success")
+        return { text: "✓ COMPLETE", fg: palette.success, bold: true };
+    if (status.tone === "warning")
+        return { text: `⚑ ${status.text}`, fg: mixHex(palette.info, palette.warning, Math.max(frame.warn, 0.5)), bold: true };
+    return { text: `● ${view.phase.toUpperCase()}`, fg: palette.info, bold: true };
+}
+function topLine(view, frame, palette, width, border, rest) {
+    const brand = [{ text: "🔥 ", fg: palette.text }, { text: "LIT", fg: shine(palette.primary, palette, 0.5, shimmerAt(frame), 0.6), bold: true }];
+    const name = view.active ? view.discipline : "ready";
+    const right = [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 = [];
+    if (nameRoom >= Math.min(4, cellWidth(name)))
+        attempts.push([withName(nameRoom), right]);
+    attempts.push([brand, right], [brand, []]);
+    for (const [left, label] of attempts) {
+        const line = ruled("╭─", left, label, "─╮", width, border);
+        if (line !== undefined)
+            return line;
+    }
+    return fitLine([{ text: "╭" + "─".repeat(Math.max(0, width)), fg: border }], width, palette);
+}
+/** 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.contextPercent !== null) {
+        const percent = Math.round(figures.contextPercent);
+        parts.push({ text: `ctx ${percent}%`, fg: percent >= contextWarnPercent ? palette.warning : palette.muted });
+    }
+    if (view.active)
+        parts.push({ text: `⟳ ${elapsedText(view.elapsedMinutes)}${figures.inLane ? " · in lane" : ""}`, fg: palette.muted });
+    if (figures.branch !== undefined)
+        parts.push({ text: `⎇ ${truncateCells(figures.branch, 24)}`, fg: palette.muted });
+    return parts;
+}
+function bottomLine(view, figures, palette, width, border) {
+    const parts = figureParts(view, figures, palette);
+    for (let count = parts.length; count >= 0; count -= 1) {
+        const right = [];
+        parts.slice(0, count).forEach((part, index) => right.push(...(index === 0 ? [] : [{ text: " · ", fg: palette.muted }]), part));
+        const line = ruled("╰", [], right, "─╯", width, border);
+        if (line !== undefined)
+            return line;
+    }
+    return fitLine([{ text: "╰" + "─".repeat(Math.max(0, width)), fg: border }], width, palette);
+}
+function trackPills(view, frame, palette, tight) {
+    const alpha = (index) => (frame.chipEnter ? ease.outCubic(seg(frame.t, index * motionTiming.stagger, motionTiming.entry)) : 1);
+    if (tight) {
+        const current = view.steps.find((step) => step.state === "now" || step.state === "warn") ?? view.steps[view.complete ? 2 : view.active ? 1 : 0];
+        return [fade(stepPill(current, view, frame, palette), alpha(0), palette)];
+    }
+    const out = [];
+    view.steps.forEach((step, index) => {
+        if (index > 0)
+            out.push(fade({ text: " ━ ", fg: view.steps[index - 1].state === "done" ? palette.success : palette.borderSubtle }, alpha(index), palette));
+        out.push(fade(stepPill(step, view, frame, palette), alpha(index), palette));
+    });
+    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 }];
+    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];
+}
+// 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.
+const trackPlans = [
+    { tight: false, bar: 16, criteria: true, text: true },
+    { tight: false, bar: 16, criteria: true, text: false },
+    { tight: false, bar: 8, criteria: true, text: false },
+    { tight: false, bar: 0, criteria: true, text: false },
+    { tight: false, bar: 0, criteria: false, text: false },
+    { tight: true, bar: 0, criteria: false, text: false }
+];
+function trackRow(view, frame, palette, width, last) {
     const sweep = shimmerAt(frame);
-    for (const plan of plans) {
-        const pills = chipGroups(view, frame, palette, plan.tier, false).flat();
-        const bar = plan.bar > 0 && view.progress !== undefined ? [{ text: "  ", fg: palette.muted }, ...progressBar(frame.barRatio, plan.bar, palette, sweep)] : [];
-        const timeWidth = plan.time ? cellWidth(time.text) + 1 : 0;
-        const fixed = lineWidth(pills) + lineWidth(bar) + timeWidth;
+    const gap = { text: "  ", fg: palette.muted };
+    for (const plan of trackPlans) {
+        const pills = trackPills(view, frame, palette, plan.tight);
+        const bar = plan.bar > 0 && view.progress !== undefined ? [gap, ...progressBar(frame.barRatio, plan.bar, palette, sweep)] : [];
+        const goal = view.goal;
+        const criteria = plan.criteria && goal !== undefined ? [gap, { text: `${goal.passed}/${goal.total} criteria`, fg: goal.total > 0 && goal.passed === goal.total ? palette.success : palette.muted }] : [];
+        const fixed = lineWidth(pills) + lineWidth(bar) + lineWidth(criteria);
         if (fixed > width)
             continue;
         const room = width - fixed;
-        const after = trailing(view, frame, palette, room);
+        const after = plan.text ? (view.active ? trailing(view, frame, palette, room) : idleText(last, palette, room)) : [];
         const keepText = plan.text && after.length > 0 && (view.complete ? lineWidth(after) <= room : room >= minimumText);
         if (plan.text && after.length > 0 && !keepText)
             continue;
-        const body = [...pills, ...bar, ...(keepText ? after : [])];
-        let used = lineWidth(body) + timeWidth;
-        const sparks = frame.celebrate !== undefined && used + chipSparkWidth <= width ? chipSparkCells(frame.celebrate, palette) : undefined;
-        if (sparks !== undefined)
-            used += chipSparkWidth;
-        const gap = width - used + (plan.time ? 1 : 0);
+        const body = [...pills, ...bar, ...criteria, ...(keepText ? after : [])];
         // Sparks sit after the text, in the free space, so the pills never shift while they play.
-        return [...body, ...(sparks ?? []), { text: " ".repeat(Math.max(plan.time ? 1 : 0, gap)), fg: palette.muted }, ...(plan.time ? [time] : [])];
+        const sparks = frame.celebrate !== undefined && lineWidth(body) + chipSparkWidth <= width ? chipSparkCells(frame.celebrate, palette) ?? [] : [];
+        return fitLine([...body, ...sparks], width, palette);
+    }
+    return fitLine(trackPills(view, frame, palette, true), width, palette);
+}
+function chipSegments(chip, shimmer, palette) {
+    const text = ` ${chip.name} `;
+    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;
+    if (sweep < 0)
+        return [{ text, fg: palette.onFill, bg: palette.accent, bold: true }];
+    const chars = [...text];
+    return chars.map((char, index) => ({ text: char, fg: palette.onFill, bg: shine(palette.accent, palette, index / (chars.length - 1), sweep, 0.3), bold: true }));
+}
+/**
+ * The skill chips row, exactly `width` cells: bright 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) {
+    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 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);
+        let shown = pills.length;
+        if (all > width) {
+            let used = lineWidth(lead);
+            shown = 0;
+            for (const pill of pills) {
+                const next = used + (shown === 0 ? 0 : 1) + lineWidth(pill);
+                if (next + cellWidth(` +${pills.length - shown - 1}`) > width)
+                    break;
+                used = next;
+                shown += 1;
+            }
+        }
+        if (shown === 0 && lead.length > 0)
+            continue;
+        const out = [...lead];
+        pills.slice(0, shown).forEach((pill, index) => out.push(...(index === 0 ? [] : [space]), ...pill));
+        if (shown < pills.length)
+            out.push({ text: `${shown === 0 ? "" : " "}+${pills.length - shown}`, fg: palette.muted });
+        return fitLine(out, width, palette);
     }
-    return [];
+    return fitLine([{ text: `+${pills.length}`, fg: palette.muted }], width, palette);
+}
+/**
+ * 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.
+ */
+export function statusCard(input, palette, width) {
+    const { frame } = input;
+    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);
+    const inner = width - 4;
+    const row = (content) => (inner < 0 ? fitLine([], width, palette) : [{ text: "│ ", fg: border }, ...fitLine(content, inner, palette), { text: " │", fg: border }]);
+    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)
+    ];
 }
 const cardRows = 4;
 /**
- * The opt-in card under the ribbon. It keeps a fixed four rows whenever a goal exists, warnings
+ * The opt-in detail card under the status card. It keeps a fixed four rows whenever a goal exists, warnings
  * first, so turning a warning on or off never moves the prompt.
  */
 export function bandCard(view, frame, palette, width) {

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

@@ -0,0 +1,38 @@
+export type SkillUse = {
+    readonly name: string;
+    readonly at: number;
+};
+export type SkillChip = {
+    readonly name: string;
+    readonly current: boolean;
+};
+/**
+ * One part as a skill use, or undefined. `at` is the owning message's time, used when the part
+ * carries no start time of its own. A failed call or a status read is not a firing.
+ */
+export declare function readSkillUse(part: unknown, at: number): SkillUse | undefined;
+/**
+ * The chips to draw: skills fired since `since` (the latest user message) are current while the
+ * session is busy, in the order they arrived; every other name is recent, newest first.
+ */
+export declare function skillChips(uses: readonly SkillUse[], turn: {
+    readonly since: number | undefined;
+    readonly busy: boolean;
+}): SkillChip[];
+export type ChipMotion = {
+    readonly at?: number;
+    readonly arrivals: readonly string[];
+};
+export declare const idleChipMotion: ChipMotion;
+/**
+ * Starts a shimmer over chips that just became current. On the first look at a session only current
+ * chips shimmer, since they belong to the running request; recent ones, the same chips again, or
+ * motion turned off leave the state as it is.
+ */
+export declare function planChipMotion(prev: readonly SkillChip[] | undefined, next: readonly SkillChip[], now: number, state: ChipMotion, enabled?: boolean): ChipMotion;
+export type ChipShimmer = {
+    readonly names: readonly string[];
+    readonly sweep: number;
+};
+/** The light sweep over arriving chips at `now`: its centre runs from just before to just past each chip. */
+export declare function chipShimmer(state: ChipMotion, now: number): ChipShimmer | undefined;

package/dist/tui/mission-skills.js

@@ -0,0 +1,81 @@
+// Skill chips for the band: which LitOpenCode skills fired in a session. Everything is read from what
+// OpenCode already stores: the built-in `skill` tool's calls, this plugin's own tool calls, and the
+// `metadata.litopencode` marks on user parts for bare `lit` routing and slash commands.
+import { litOpenCodeRuntimeSkills, litOpenCodeStaticOnlySkills } from "../skills.js";
+import { seg, motionTiming } from "./mission-motion.js";
+import { readLitMark } from "./mission-model.js";
+const ownSkills = new Set([...litOpenCodeRuntimeSkills, ...litOpenCodeStaticOnlySkills].map((skill) => skill.id));
+// LitOpenCode's own tools, by the chip each one shows. The `lit` tool activates lit-loop.
+const ownTools = { lit: "lit-loop", litwork: "litwork", "start-work": "start-work", "review-work": "review-work", wikify: "wikify" };
+const recentLimit = 12;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * One part as a skill use, or undefined. `at` is the owning message's time, used when the part
+ * carries no start time of its own. A failed call or a status read is not a firing.
+ */
+export function readSkillUse(part, at) {
+    if (!isRecord(part))
+        return undefined;
+    if (part.type === "tool" && typeof part.tool === "string" && isRecord(part.state)) {
+        const state = part.state;
+        if (state.status === "error")
+            return undefined;
+        const input = isRecord(state.input) ? state.input : {};
+        const start = isRecord(state.time) && typeof state.time.start === "number" ? state.time.start : at;
+        if (part.tool === "skill") {
+            return typeof input.name === "string" && ownSkills.has(input.name) ? { name: input.name, at: start } : undefined;
+        }
+        const name = ownTools[part.tool];
+        if (name === undefined || input.action === "status")
+            return undefined;
+        return { name, at: start };
+    }
+    const mark = readLitMark(part.metadata, at);
+    if (mark === undefined)
+        return undefined;
+    const name = mark.mode !== undefined && mark.mode !== "bounded-authority-lifecycle" ? mark.command ?? mark.mode : mark.command;
+    return name === undefined ? undefined : { name, at };
+}
+/**
+ * The chips to draw: skills fired since `since` (the latest user message) are current while the
+ * session is busy, in the order they arrived; every other name is recent, newest first.
+ */
+export function skillChips(uses, turn) {
+    const ordered = [...uses].sort((left, right) => left.at - right.at);
+    const last = new Map();
+    const current = [];
+    for (const use of ordered) {
+        last.set(use.name, use.at);
+        if (turn.busy && turn.since !== undefined && use.at >= turn.since && !current.includes(use.name))
+            current.push(use.name);
+    }
+    const recent = [...last.entries()]
+        .filter(([name]) => !current.includes(name))
+        .sort((left, right) => right[1] - left[1])
+        .slice(0, recentLimit)
+        .map(([name]) => ({ name, current: false }));
+    return [...current.map((name) => ({ name, current: true })), ...recent];
+}
+export const idleChipMotion = Object.freeze({ arrivals: Object.freeze([]) });
+/**
+ * Starts a shimmer over chips that just became current. On the first look at a session only current
+ * chips shimmer, since they belong to the running request; recent ones, the same chips again, or
+ * motion turned off leave the state as it is.
+ */
+export function planChipMotion(prev, next, now, state, enabled = true) {
+    if (!enabled)
+        return state;
+    const arrivals = next.filter((chip) => chip.current && !(prev ?? []).some((before) => before.name === chip.name && before.current)).map((chip) => chip.name);
+    return arrivals.length === 0 ? state : { at: now, arrivals };
+}
+/** The light sweep over arriving chips at `now`: its centre runs from just before to just past each chip. */
+export function chipShimmer(state, now) {
+    if (state.at === undefined || state.arrivals.length === 0)
+        return undefined;
+    const t = now - state.at;
+    if (t < 0 || t > motionTiming.shimmer)
+        return undefined;
+    return { names: state.arrivals, sweep: -0.2 + 1.4 * seg(t, 0, motionTiming.shimmer) };
+}

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

@@ -1,4 +1,5 @@
 import { type MissionInput, type TodoInput } from "./mission-model.ts";
+import { type SkillChip } from "./mission-skills.ts";
 type MessageLike = {
     readonly id: string;
     readonly role: string;
@@ -23,6 +24,9 @@ export type MissionStateSource = {
         readonly worktree?: string;
         readonly directory?: string;
     };
+    readonly vcs?: {
+        readonly branch?: string;
+    };
     readonly provider: ReadonlyArray<{
         readonly id: string;
         readonly models: Readonly<Record<string, {
@@ -42,6 +46,7 @@ export type MissionStateSource = {
         question(sessionID: string): ReadonlyArray<unknown>;
     };
     part(messageID: string): ReadonlyArray<{
+        readonly type?: string;
         readonly metadata?: unknown;
     }>;
 };
@@ -53,4 +58,16 @@ export declare function missionProjectRoot(paths: MissionStateSource["path"]): s
  */
 export declare function createLedgerReader(): (root: string | undefined) => unknown;
 export declare function readMissionInput(state: MissionStateSource, sessionID: string, ledger: unknown, now: number): MissionInput;
+export type CardInput = {
+    readonly chips: readonly SkillChip[];
+    readonly busy: boolean;
+    readonly contextPercent: number | null;
+    readonly branch?: string;
+};
+/**
+ * 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 {};