@litfamily/litopencode 1.0.17 → 1.0.19

package/dist/cli/plugin-mutation.js

@@ -9,18 +9,23 @@ function pluginEntryId(value) {
         return value[0];
     return "";
 }
+// The install target counts as a LitOpenCode entry even when it is a local checkout path, which the
+// package-name match cannot recognize; otherwise a re-install would append the same path again.
+function isRegistrationEntry(value, target) {
+    return isLitOpenCodeEntry(value) || pluginEntryId(value) === target;
+}
 function replaceLitOpenCodeEntry(value, target) {
-    if (Array.isArray(value) && isLitOpenCodeEntry(value))
+    if (Array.isArray(value))
         return [target, ...value.slice(1)];
     return target;
 }
 function normalizedPluginArray(pluginValue, target) {
-    const firstLitEntry = pluginValue.find(isLitOpenCodeEntry);
+    const firstLitEntry = pluginValue.find((value) => isRegistrationEntry(value, target));
     const replacement = firstLitEntry === undefined ? target : replaceLitOpenCodeEntry(firstLitEntry, target);
     let replaced = false;
     const next = [];
     for (const value of pluginValue) {
-        if (!isLitOpenCodeEntry(value)) {
+        if (!isRegistrationEntry(value, target)) {
             next.push(value);
             continue;
         }
@@ -34,9 +39,9 @@ function normalizedPluginArray(pluginValue, target) {
 export function describePluginMutation(config, target) {
     const pluginValue = config?.plugin;
     const pluginIsArray = Array.isArray(pluginValue);
-    const existingIndex = pluginIsArray ? pluginValue.findIndex(isLitOpenCodeEntry) : -1;
+    const existingIndex = pluginIsArray ? pluginValue.findIndex((value) => isRegistrationEntry(value, target)) : -1;
     const targetIndex = pluginIsArray ? pluginValue.findIndex((value) => pluginEntryId(value) === target) : -1;
-    const litEntryCount = pluginIsArray ? pluginValue.filter(isLitOpenCodeEntry).length : 0;
+    const litEntryCount = pluginIsArray ? pluginValue.filter((value) => isRegistrationEntry(value, target)).length : 0;
     const alreadyPresent = targetIndex >= 0 && litEntryCount === 1;
     const currentCount = pluginIsArray ? pluginValue.length : 0;
     if (alreadyPresent) {
@@ -81,7 +86,7 @@ export function applyPluginMutation(config, mutation, target) {
         return next;
     const pluginValue = next.plugin;
     if (Array.isArray(pluginValue)) {
-        next.plugin = pluginValue.some(isLitOpenCodeEntry) ? normalizedPluginArray(pluginValue, target) : [...pluginValue, target];
+        next.plugin = pluginValue.some((value) => isRegistrationEntry(value, target)) ? normalizedPluginArray(pluginValue, target) : [...pluginValue, target];
         return next;
     }
     next.plugin = [target];

package/dist/cli/tui-config.d.ts

@@ -0,0 +1,52 @@
+export declare const tuiSchemaUrl = "https://opencode.ai/tui.json";
+export declare const tuiBackupSuffix = ".litopencode-backup";
+type PlannedWrite = {
+    readonly path: string;
+    readonly before: string | null;
+    readonly text: string;
+};
+export type TuiInstallReport = {
+    readonly path: string;
+    readonly alreadyPresent: boolean;
+    readonly changed: boolean;
+    readonly add: readonly string[];
+    readonly currentCount: number;
+    readonly resultCount: number;
+    readonly cleaned: readonly string[];
+};
+export type TuiInstallPlan = {
+    readonly report: TuiInstallReport;
+    readonly writes: readonly PlannedWrite[];
+    readonly blocked?: string;
+};
+export type TuiRemovalReport = {
+    readonly dryRun: boolean;
+    readonly removed: number;
+    readonly files: readonly {
+        readonly path: string;
+        readonly removed: number;
+        readonly backup?: string;
+    }[];
+};
+export declare function tuiConfigCandidates(root: string): readonly [string, string];
+/** Works out every TUI config edit an install makes, without writing. A comment that would be lost blocks the plan. */
+export declare function planTuiInstall(root: string, target: string): Promise<TuiInstallPlan>;
+/** Writes a plan: each file that already existed is copied to `<file>.litopencode-backup` first. */
+export declare function applyTuiWrites(writes: readonly PlannedWrite[], options?: {
+    readonly backup?: boolean;
+}): Promise<void>;
+/** Backs up the TUI files a plan is about to change, for writers outside LitOpenCode such as `opencode plugin`. */
+export declare function backupTuiFiles(plan: TuiInstallPlan): Promise<void>;
+/** Removes LitOpenCode's own TUI entries, and only those, from tui.json and tui.jsonc. */
+export declare function removeTuiPlugin(root: string, dryRun: boolean): Promise<TuiRemovalReport>;
+export type TuiInspection = {
+    readonly path: string;
+    readonly expected: string;
+    readonly configured: string | null;
+    readonly present: boolean;
+    readonly entries: number;
+    readonly ok: boolean;
+    readonly error?: string;
+};
+export declare function inspectTuiPlugin(root: string, expected: string): Promise<TuiInspection>;
+export {};

package/dist/cli/tui-config.js

@@ -0,0 +1,198 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { OpenCodeConfigCommentError, renderOpenCodeConfig, writeTextAtomically } from "./install-config.js";
+import { isRecord, readJsonObjectIfPresent, readTextIfPresent } from "./json.js";
+import { parseJsonc } from "./jsonc.js";
+import { isLitOpenCodeEntry } from "./plugin-mutation.js";
+// OpenCode reads TUI plugins from the `plugin` list of tui.json and tui.jsonc beside opencode.json,
+// merging both. When it adds an entry itself it edits the first of the two that exists, else creates
+// tui.json; LitOpenCode follows the same choice so a host install and ours never split the entry.
+export const tuiSchemaUrl = "https://opencode.ai/tui.json";
+export const tuiBackupSuffix = ".litopencode-backup";
+export function tuiConfigCandidates(root) {
+    const resolved = path.resolve(root);
+    return [path.join(resolved, "tui.json"), path.join(resolved, "tui.jsonc")];
+}
+function entryId(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value) && typeof value[0] === "string")
+        return value[0];
+    return "";
+}
+async function isLitOpenCodePathEntry(root, id) {
+    if (!(path.isAbsolute(id) || id.startsWith(".")))
+        return false;
+    const metadata = await readJsonObjectIfPresent(path.join(path.resolve(root, id), "package.json")).catch(() => null);
+    return metadata?.name === "litopencode" || metadata?.name === "@litfamily/opencode" || metadata?.name === "@litfamily/litopencode";
+}
+async function isOwnEntry(root, value, target) {
+    const id = entryId(value);
+    return id !== "" && (id === target || isLitOpenCodeEntry(value) || (await isLitOpenCodePathEntry(root, id)));
+}
+async function readTuiFile(file) {
+    const text = await readTextIfPresent(file);
+    if (text === null)
+        return { path: file, text, config: null };
+    let parsed;
+    try {
+        parsed = parseJsonc(text);
+    }
+    catch (error) {
+        throw new Error(`Malformed JSONC at ${file}: ${error instanceof Error ? error.message : String(error)}. Nothing was written.`);
+    }
+    if (!isRecord(parsed))
+        throw new Error(`Malformed JSON at ${file}: expected an object. Nothing was written.`);
+    return { path: file, text, config: parsed };
+}
+async function ownIndexes(root, plugins, target) {
+    const indexes = [];
+    for (const [index, value] of plugins.entries())
+        if (await isOwnEntry(root, value, target))
+            indexes.push(index);
+    return indexes;
+}
+function pluginList(config) {
+    return Array.isArray(config?.plugin) ? config.plugin : [];
+}
+function render(file, next) {
+    return { path: file.path, before: file.text, text: renderOpenCodeConfig(file.path, file.text, next) };
+}
+/** Works out every TUI config edit an install makes, without writing. A comment that would be lost blocks the plan. */
+export async function planTuiInstall(root, target) {
+    const files = await Promise.all(tuiConfigCandidates(root).map(readTuiFile));
+    const owned = await Promise.all(files.map(async (file) => ownIndexes(root, pluginList(file.config), target)));
+    const holder = files.findIndex((_file, index) => owned[index].length > 0);
+    const primaryIndex = holder >= 0 ? holder : Math.max(0, files.findIndex((file) => file.text !== null));
+    const primary = files[primaryIndex];
+    const current = pluginList(primary.config);
+    const primaryOwned = owned[primaryIndex];
+    const alreadyPresent = primaryOwned.length === 1 && entryId(current[primaryOwned[0]]) === target;
+    let nextPlugins;
+    if (primaryOwned.length === 0) {
+        nextPlugins = [...current, target];
+    }
+    else {
+        const first = current[primaryOwned[0]];
+        const replacement = Array.isArray(first) ? [target, ...first.slice(1)] : target;
+        nextPlugins = current.flatMap((value, index) => (index === primaryOwned[0] ? [replacement] : primaryOwned.includes(index) ? [] : [value]));
+    }
+    const writes = [];
+    const cleaned = [];
+    try {
+        if (JSON.stringify(nextPlugins) !== JSON.stringify(current) || primary.config === null) {
+            const base = primary.config === null ? { $schema: tuiSchemaUrl } : primary.config;
+            writes.push(render(primary, { ...base, plugin: nextPlugins }));
+        }
+        for (const [index, file] of files.entries()) {
+            if (index === primaryIndex || owned[index].length === 0 || file.config === null)
+                continue;
+            const kept = pluginList(file.config).filter((_value, position) => !owned[index].includes(position));
+            writes.push(render(file, { ...file.config, plugin: kept }));
+            cleaned.push(file.path);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof OpenCodeConfigCommentError))
+            throw error;
+        return { report: { ...report(), changed: true, add: [target] }, writes: [], blocked: error.message };
+    }
+    return { report: report(), writes };
+    function report() {
+        const changed = writes.length > 0;
+        return {
+            path: primary.path,
+            alreadyPresent,
+            changed,
+            add: changed ? [target] : [],
+            currentCount: current.length,
+            resultCount: nextPlugins.length,
+            cleaned
+        };
+    }
+}
+async function backup(write) {
+    if (write.before === null)
+        return undefined;
+    const file = write.path + tuiBackupSuffix;
+    await writeTextAtomically(file, write.before);
+    return file;
+}
+/** Writes a plan: each file that already existed is copied to `<file>.litopencode-backup` first. */
+export async function applyTuiWrites(writes, options = {}) {
+    for (const write of writes) {
+        if (options.backup !== false)
+            await backup(write);
+        await fs.mkdir(path.dirname(write.path), { recursive: true });
+        await writeTextAtomically(write.path, write.text);
+    }
+}
+/** Backs up the TUI files a plan is about to change, for writers outside LitOpenCode such as `opencode plugin`. */
+export async function backupTuiFiles(plan) {
+    for (const write of plan.writes)
+        await backup(write);
+}
+/** Removes LitOpenCode's own TUI entries, and only those, from tui.json and tui.jsonc. */
+export async function removeTuiPlugin(root, dryRun) {
+    const files = await Promise.all(tuiConfigCandidates(root).map(readTuiFile));
+    const writes = [];
+    for (const file of files) {
+        if (file.config === null)
+            continue;
+        const plugins = pluginList(file.config);
+        const owned = await ownIndexes(root, plugins, undefined);
+        if (owned.length === 0)
+            continue;
+        const kept = plugins.filter((_value, index) => !owned.includes(index));
+        writes.push({ write: render(file, { ...file.config, plugin: kept }), removed: owned.length });
+    }
+    const reports = [];
+    for (const { write, removed } of writes) {
+        if (dryRun) {
+            reports.push({ path: write.path, removed });
+            continue;
+        }
+        const backupPath = await backup(write);
+        await writeTextAtomically(write.path, write.text);
+        reports.push({ path: write.path, removed, ...(backupPath === undefined ? {} : { backup: backupPath }) });
+    }
+    return { dryRun, removed: reports.reduce((total, entry) => total + entry.removed, 0), files: reports };
+}
+export async function inspectTuiPlugin(root, expected) {
+    let files;
+    try {
+        files = await Promise.all(tuiConfigCandidates(root).map(readTuiFile));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { path: tuiConfigCandidates(root)[0], expected, configured: null, present: false, entries: 0, ok: false, error: message };
+    }
+    let found;
+    let entries = 0;
+    let present = false;
+    for (const file of files) {
+        for (const value of pluginList(file.config)) {
+            const id = entryId(value);
+            const exact = id === expected || (await isLitOpenCodePathEntry(root, id));
+            if (!exact && !isLitOpenCodeEntry(value))
+                continue;
+            entries += 1;
+            if (exact && !present) {
+                present = true;
+                found = { path: file.path, id };
+            }
+            else if (found === undefined) {
+                found = { path: file.path, id };
+            }
+        }
+    }
+    const fallback = files.find((file) => file.text !== null)?.path ?? files[0].path;
+    return {
+        path: found?.path ?? fallback,
+        expected,
+        configured: found?.id ?? null,
+        present,
+        entries,
+        ok: present && entries === 1
+    };
+}

package/dist/cli/types.d.ts

@@ -1,4 +1,5 @@
 import type { OpenCodeHostCapabilities } from "./host-capabilities.ts";
+import type { TuiInstallReport } from "./tui-config.ts";
 export type CliResult = {
     readonly exitCode: number;
     readonly stdout?: string;
@@ -25,6 +26,7 @@ export type ParsedArgs = {
     readonly modelPrompt: ModelPromptMode;
     readonly outputStylePrompt: PermissionPromptMode;
     readonly loop: LoopArgs;
+    readonly tuiAction?: string;
 };
 export type LoopArgs = {
     readonly projectRoot: string;
@@ -181,8 +183,10 @@ export type InstallReport = {
         readonly compactionTriggerTokens: number;
         readonly compactionReserveTokens: number;
     };
+    readonly tui: TuiInstallReport;
     readonly patch: readonly JsonPatchOperation[];
     readonly changed: boolean;
+    readonly blocked?: string;
     readonly routes?: InstallRouteReport;
     readonly capabilities: OpenCodeHostCapabilities;
     readonly package: Pick<PackageMetadata, "name" | "version">;

package/dist/cli.js

@@ -10,6 +10,7 @@ import { defaultOpenAiRoutes, legacyFastAliasHelp, modelEffortHelp, openaiModelH
 import { fetchPublicSource } from "./lit-fetch.js";
 import { readPackageMetadata } from "./cli/json.js";
 import { runMotionRuntime } from "./cli/motion-runtime.js";
+import { removeTuiPlugin } from "./cli/tui-config.js";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 function helpText() {
@@ -34,7 +35,8 @@ function helpText() {
         "  litopencode install [--permission-prompt | --no-permission-prompt] [--permission-mode <safe|balanced|yolo>]",
         "  litopencode install|doctor [--no-auto-update]",
         "  litopencode doctor [--json] [--root <dir>]",
-        "  litopencode motion-runtime install|status [--audio] [--word-timing]",
+        "  litopencode tui remove [--dry-run] [--root <dir>]",
+        "  litopencode motion-runtime install|status [--audio] [--word-timing] [--dry-run] (install) [--json] (status)",
         "  litopencode fetch-public <url> [--json] [--timeout <ms>] [--max-bytes <n>]",
         "  litopencode fetch-public <local-url> --json --allow-private-network  # trusted fixtures only",
         "  OpenCode /start-work init|resume|cancel|complete|status <schema-3 JSON>",
@@ -52,6 +54,7 @@ function helpText() {
         "Commands:",
         "  install       Register litopencode with OpenCode using a branded installer UI.",
         "  doctor        Report package, config, and runtime path status without writing files.",
+        "  tui remove    Remove only LitOpenCode's TUI panel entry from tui.json/tui.jsonc (backed up first).",
         "  fetch-public  Fetch a public URL with SSRF guards, verdicts, and trace output.",
         "                --allow-private-network is opt-in for reviewed local fixtures or trusted internal tests.",
         "",
@@ -118,7 +121,7 @@ function helpText() {
 export async function runCli(argv = process.argv.slice(2), options = {}) {
     if (argv[0] === "motion-runtime") {
         const metadata = await readPackageMetadata();
-        return runMotionRuntime(metadata.packageRoot, argv.slice(1));
+        return await runMotionRuntime(metadata.packageRoot, argv.slice(1));
     }
     let parsed;
     try {
@@ -133,9 +136,11 @@ export async function runCli(argv = process.argv.slice(2), options = {}) {
             return { exitCode: 0, stdout: helpText() };
         }
         if (isLoopCommand(parsed.command))
-            return await runLoopCommand(parsed.command, parsed.loop);
+            return await runLoopCommand(parsed.command, parsed.loop, parsed.dryRun);
         if (parsed.command === "doctor")
             return await doctor(parsed.root);
+        if (parsed.command === "tui")
+            return { exitCode: 0, stdout: JSON.stringify(await removeTuiPlugin(parsed.root, parsed.dryRun), null, 2) };
         if (parsed.command === "fetch-public") {
             if (!parsed.fetchPublicUrl)
                 return { exitCode: 2, stderr: "fetch-public requires a URL" };

package/dist/deliverable-hedge-guard.js

@@ -2,14 +2,15 @@ import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { childNodeExecutable } from "./cli/auto-update.js";
 import { mutatedFilePaths } from "./tool-guards.js";
 const defaultTimeoutMs = 1500;
 const maxTextBytes = 4 * 1024 * 1024;
 const maxOutputBytes = 16 * 1024 * 1024;
 const maxPendingCalls = 512;
+// Prose formats only: in config and data files (YAML, JSON, XML, CSV, TSV) a line such as `source:` is a key.
 const readerFacingExtensions = new Set([
-    ".adoc", ".csv", ".html", ".htm", ".md", ".mdx", ".org", ".rst", ".svg", ".tex", ".txt", ".tsv",
-    ".xhtml", ".xml", ".json", ".jsonc", ".yaml", ".yml"
+    ".adoc", ".html", ".htm", ".md", ".mdx", ".org", ".rst", ".svg", ".tex", ".txt", ".xhtml"
 ]);
 const officeExtensions = new Set([".docx", ".pptx", ".pdf"]);
 const packageSkillRoot = fileURLToPath(new URL("../skills/lit-humanizer", import.meta.url));
@@ -108,7 +109,8 @@ function runJsonProcess(command, args, input, timeoutMs) {
     });
 }
 async function defaultScan(request, timeoutMs) {
-    const raw = await runJsonProcess(process.execPath, [detectorWorker], JSON.stringify(request), timeoutMs);
+    // Inside OpenCode, process.execPath is the Bun host binary, which cannot run the worker script.
+    const raw = await runJsonProcess(childNodeExecutable(), [detectorWorker], JSON.stringify(request), timeoutMs);
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.findings))
         throw new Error("detector returned an invalid response");

package/dist/hooks.js

@@ -7,7 +7,8 @@ export function createToolExecuteBeforeHook(options = {}) {
     return async (input, output) => {
         await applyTaskRecursionGuard(input, options.getSession);
         applyLitOpenCodeToolBeforeHook(input, output);
-        await options.deliverableHedgeGuard?.before(input);
+        // OpenCode sends the tool arguments only in output.args before a call.
+        await options.deliverableHedgeGuard?.before({ ...input, args: output.args ?? input.args });
     };
 }
 export function createToolExecuteAfterHook(options = {}) {

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

@@ -0,0 +1,29 @@
+import { type MotionFrame } from "./mission-motion.ts";
+import type { MissionView } from "./mission-model.ts";
+import { 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.
+ */
+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.
+ */
+export declare function bandRibbon(view: MissionView, frame: MotionFrame, palette: MissionPalette, width: number, place: {
+    readonly inLane: boolean;
+}): 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
+ * 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

@@ -0,0 +1,116 @@
+// 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";
+/**
+ * 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.
+ */
+export function readBandOptions(options) {
+    const band = typeof options === "object" && options !== null ? options.band : undefined;
+    if (band === false)
+        return { enabled: false, card: false };
+    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);
+    return total < 60 ? `${total}m` : `${Math.floor(total / 60)}h${String(total % 60).padStart(2, "0")}`;
+}
+/** The text after the bar: a warning (⚑ and words) replaces the next task; a finished mission shows COMPLETE. */
+function trailing(view, frame, palette, room) {
+    if (view.complete) {
+        // Before COMPLETE pops in, the slot stays empty rather than flashing the header's "● active".
+        if (frame.celebrate !== undefined && frame.celebrate < motionTiming.popAt)
+            return [];
+        const status = statusSegments(view, frame, palette);
+        const lead = Math.max(1, 2 + status.offset);
+        return [{ text: " ".repeat(lead), fg: palette.muted }, ...status.segments];
+    }
+    const warning = view.warnings[0];
+    if (warning !== undefined) {
+        const color = warning.kind === "retry" ? mixHex(palette.warning, palette.error, 0.5) : palette.warning;
+        return [{ text: "  ⚑ ", fg: color, bold: true }, { text: truncateCells(warning.text, room - 4), fg: color }];
+    }
+    if (view.next === undefined)
+        return [];
+    return [{ text: "  ▸ ", fg: palette.muted }, { text: truncateCells(view.next, room - 4), fg: palette.text }];
+}
+/**
+ * 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.
+ */
+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 };
+    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;
+        if (fixed > width)
+            continue;
+        const room = width - fixed;
+        const after = trailing(view, frame, 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);
+        // 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] : [])];
+    }
+    return [];
+}
+const cardRows = 4;
+/**
+ * The opt-in card under the ribbon. 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) {
+    if (!view.active || (view.goal === undefined && view.warnings.length === 0))
+        return undefined;
+    const panel = missionPanel(view, frame, palette);
+    if (panel === undefined)
+        return undefined;
+    const inner = Math.max(8, width - 4);
+    const rows = [];
+    for (const warning of view.warnings.slice(0, 2)) {
+        rows.push([{ text: "⚑ ", fg: palette.warning, bold: true }, { text: truncateCells(warning.text, inner - 2), fg: palette.warning }]);
+    }
+    if (view.next !== undefined && !view.complete)
+        rows.push([{ text: "next  ", fg: palette.muted }, { text: truncateCells(`▸ ${view.next}`, inner - 6), fg: palette.text }]);
+    if (view.goal !== undefined) {
+        const criteria = view.goal.criteria.map((criterion) => `${criterion.status === "pass" ? "✓" : criterion.status === "fail" ? "✗" : "○"}${criterion.id}`).join(" ");
+        const title = truncateCells(view.goal.title, Math.max(4, inner - 8 - cellWidth(criteria)));
+        rows.push([
+            { text: "goal  ", fg: palette.muted },
+            { text: title, fg: palette.text, bold: true },
+            { text: "  ", fg: palette.muted },
+            { text: truncateCells(criteria, Math.max(0, inner - 8 - cellWidth(title))), fg: palette.muted }
+        ]);
+    }
+    while (rows.length < cardRows)
+        rows.push([]);
+    return { title: panel.title, border: panel.border, rows: rows.slice(0, cardRows) };
+}