tickmarkr 1.78.0 → 1.80.0

package/dist/gates/review.js

@@ -4,7 +4,7 @@ import { renderAcceptanceItem } from "../graph/schema.js";
 import { getAdapter } from "../adapters/registry.js";
 import { shOk } from "../run/git.js";
 import { marginalCostRank } from "../route/router.js";
-import { COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlm, verdictNonceLine } from "./llm.js";
+import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlm, verdictNonceLine } from "./llm.js";
 // legacy flat `issues` shape — every issue blocks; the approve flag must agree with the list.
 function classifyReviewIssues(approve, issues) {
     const inconsistencies = [];
@@ -158,8 +158,9 @@ block approval. For a minor concern you have decided not to block on, set "defer
 one-line "rationale" — it is recorded in the review, never dropped.
 
 Respond with ONLY this JSON:
-{"nonce": "${nonce}", "approve": true|false, "findings": [{"note": "...", "severity": "material"|"minor", "defer": false, "rationale": ""}]}
+{"nonce": "${nonce}", "approve": true|false, "findings": [{"note": "...", "severity": "material"|"minor", "defer": false, "rationale": ""}], "comments": [{"path": "path/to/file", "line": 42, "body": "actionable feedback"}]}
 Approve iff no material finding remains; an empty findings list is a clean approval.
+The top-level comments array is optional. Use it only for actionable line-anchored feedback.
 `;
     const raw = await runLlm(getAdapter(reviewer.adapter, adapters), reviewer.model, prompt, worktree, via ? { driver: via.driver, keep: via.keep, onSlot: via.onSlot, name: via.nameFor("review", reviewer.adapter), label: via.labelFor("review") } : undefined, 
     // frontier reviewers routinely need >5min on a configured-cap-sized diff, and `claude -p` buffers all
@@ -182,10 +183,11 @@ Approve iff no material finding remains; an empty findings list is a clean appro
     const decided = findings !== null
         ? classifyReviewFindings(findings)
         : classifyReviewIssues(v.approve, v.issues);
+    const prose = `reviewer ${reviewer.adapter}:${reviewer.model} (${reviewer.vendor}): ${decided.headline}${decided.lines.length ? "\n" + decided.lines.join("\n") : ""}`;
     return {
         gate: "review",
         pass: decided.pass,
-        details: `reviewer ${reviewer.adapter}:${reviewer.model} (${reviewer.vendor}): ${decided.headline}${decided.lines.length ? "\n" + decided.lines.join("\n") : ""}`,
+        details: appendAnchoredReview(prose, v),
         meta: { reviewer: channelKey(reviewer) },
     };
 }

package/dist/run/journal.d.ts

@@ -85,12 +85,12 @@ export declare const TelemetryRowSchema: z.ZodObject<{
     }>>;
     signalQuality: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<0.75>, z.ZodLiteral<1>]>>;
     signalBasis: z.ZodOptional<z.ZodEnum<{
+        skipped: "skipped";
         proved: "proved";
         "review-agree": "review-agree";
         "judge-only": "judge-only";
         legacy: "legacy";
         vacuous: "vacuous";
-        skipped: "skipped";
     }>>;
     kind: z.ZodOptional<z.ZodLiteral<"judge">>;
     judgeOutcome: z.ZodOptional<z.ZodEnum<{

package/dist/tui/cockpit/capture.d.ts

@@ -0,0 +1,117 @@
+import { type ReactNode } from "react";
+import { type DemoCaptures } from "./demo.js";
+export type CockpitName = "run" | "setup";
+export type CockpitRenderer = "frame" | "plain";
+export type RendererCaptureOptions = {
+    readonly columns: number;
+    readonly rows: number;
+    readonly colour: boolean;
+};
+export type FrameRenderer = (node: ReactNode, options: RendererCaptureOptions) => Promise<string>;
+export type CockpitEmission = {
+    readonly renderer: CockpitRenderer;
+    readonly output: string;
+};
+export type CaptureCockpitOptions = {
+    readonly cockpit: CockpitName;
+    readonly output: NodeJS.WriteStream;
+    readonly binaryVersion: string;
+    readonly columns?: number;
+    readonly rows?: number;
+    readonly interactive?: boolean;
+    readonly colour?: boolean;
+    readonly ci?: boolean;
+    readonly captures?: DemoCaptures;
+    readonly plainRenderer?: (cockpit: CockpitName, binaryVersion: string, captures: DemoCaptures) => string;
+    readonly frameRenderer?: FrameRenderer;
+};
+export type WidthBandCase = {
+    readonly arrangement: "stacked" | "folded-keys" | "three-column";
+    readonly columns: number;
+};
+export declare const WIDTH_BAND_CASES: readonly [{
+    readonly arrangement: "stacked";
+    readonly columns: 80;
+}, {
+    readonly arrangement: "folded-keys";
+    readonly columns: 100;
+}, {
+    readonly arrangement: "three-column";
+    readonly columns: 140;
+}];
+export declare const HEIGHT_TIER_BOUNDARIES: readonly [14, 18, 24, 40];
+export type GoldenFrameCase = {
+    readonly id: string;
+    readonly fixture: string;
+    readonly cockpit: CockpitName;
+    readonly axis: "width" | "height" | "variant";
+    readonly columns: number;
+    readonly rows: number;
+    readonly interactive: boolean;
+    readonly colour: boolean;
+    readonly ci: boolean;
+};
+export declare const GOLDEN_FRAME_CASES: readonly GoldenFrameCase[];
+export type ColourFrameCase = {
+    readonly id: "healthy-colour" | "healthy-no-colour" | "warning-failure-colour";
+    readonly fixture: string;
+    readonly sourceFileName: string;
+    readonly columns: number;
+    readonly rows: number;
+    readonly colour: boolean;
+};
+/**
+ * The colour corpus has a deliberately separate manifest from the layout
+ * corpus. Layout cases stay colourless; these cases alone exercise real ink.
+ */
+export declare const COLOUR_FRAME_CASES: readonly [{
+    readonly id: "healthy-colour";
+    readonly fixture: "run-20260718-000943.colour.140x24.txt";
+    readonly sourceFileName: "run-20260718-000943.journal.jsonl";
+    readonly columns: 140;
+    readonly rows: 24;
+    readonly colour: true;
+}, {
+    readonly id: "healthy-no-colour";
+    readonly fixture: "run-20260718-000943.no-colour.140x24.txt";
+    readonly sourceFileName: "run-20260718-000943.journal.jsonl";
+    readonly columns: 140;
+    readonly rows: 24;
+    readonly colour: false;
+}, {
+    readonly id: "warning-failure-colour";
+    readonly fixture: "run-20260725-025004.interrupted.colour.140x24.txt";
+    readonly sourceFileName: "run-20260725-025004.interrupted.journal.jsonl";
+    readonly columns: 140;
+    readonly rows: 24;
+    readonly colour: true;
+}];
+/**
+ * Capture exactly the bytes Ink writes for one static paint. Debug mode is
+ * deliberate: it exposes the complete frame rather than terminal patch
+ * instructions, so the committed corpus is the renderer's frame output.
+ */
+export declare function captureRendererOutput(node: ReactNode, options: RendererCaptureOptions): Promise<string>;
+/**
+ * The single interactive/plain boundary. It decides before mounting Ink, then
+ * falls back again if a renderer returns an empty paint.
+ */
+export declare function captureCockpitOutput(options: CaptureCockpitOptions): Promise<CockpitEmission>;
+export type RegeneratedGoldenFrame = GoldenFrameCase & {
+    readonly renderer: CockpitRenderer;
+    readonly output: string;
+    readonly emitted: string;
+};
+export declare function regenerateGoldenFrames(binaryVersion?: string): Promise<readonly RegeneratedGoldenFrame[]>;
+export declare function findGoldenFrameMismatches(regenerated: readonly RegeneratedGoldenFrame[], committed: ReadonlyMap<string, string>): string[];
+export type RegeneratedColourFrame = ColourFrameCase & {
+    readonly output: string;
+    readonly emitted: string;
+};
+/**
+ * Regenerate only the colour contract corpus from its own manifest. Historical
+ * run sources are read and rendered byte-for-byte with their captured daemon
+ * stopped, matching the demo path and avoiding live-process state in committed
+ * bytes.
+ */
+export declare function regenerateColourFrames(binaryVersion?: string): Promise<readonly RegeneratedColourFrame[]>;

package/dist/tui/cockpit/capture.js

@@ -0,0 +1,329 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { PassThrough } from "node:stream";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { render } from "ink";
+import { cloneElement, createElement, isValidElement, } from "react";
+import { GLYPHS } from "../../brand.js";
+import { version } from "../../cli/commands/version.js";
+import { KEYBAR_KEYS } from "./components.js";
+import { loadDemoCaptures } from "./demo.js";
+import { resolveCockpitLayout, } from "./layout.js";
+import { deriveRunCockpitData, RunCockpitFrame, } from "./run-cockpit.js";
+import { deriveSetupCockpitData, SetupCockpitFrame, } from "./setup-cockpit.js";
+export const WIDTH_BAND_CASES = [
+    { arrangement: "stacked", columns: 80 },
+    { arrangement: "folded-keys", columns: 100 },
+    { arrangement: "three-column", columns: 140 },
+];
+export const HEIGHT_TIER_BOUNDARIES = [14, 18, 24, 40];
+const fixtureName = (cockpit, id, columns, rows) => `${cockpit}.${id}.${columns}x${rows}.txt`;
+const goldenCasesFor = (cockpit) => [
+    ...WIDTH_BAND_CASES.map(({ arrangement, columns }) => ({
+        id: `${cockpit}-width-${arrangement}`,
+        fixture: fixtureName(cockpit, `width-${arrangement}`, columns, 24),
+        cockpit,
+        axis: "width",
+        columns,
+        rows: 24,
+        interactive: true,
+        colour: false,
+        ci: false,
+    })),
+    ...HEIGHT_TIER_BOUNDARIES.map((rows) => ({
+        id: `${cockpit}-height-${rows}`,
+        fixture: fixtureName(cockpit, `height-${rows}`, 140, rows),
+        cockpit,
+        axis: "height",
+        columns: 140,
+        rows,
+        interactive: true,
+        colour: false,
+        ci: false,
+    })),
+    {
+        id: `${cockpit}-no-colour`,
+        fixture: fixtureName(cockpit, "no-colour", 140, 24),
+        cockpit,
+        axis: "variant",
+        columns: 140,
+        rows: 24,
+        interactive: true,
+        colour: false,
+        ci: false,
+    },
+    {
+        id: `${cockpit}-non-tty`,
+        fixture: fixtureName(cockpit, "non-tty", 140, 24),
+        cockpit,
+        axis: "variant",
+        columns: 140,
+        rows: 24,
+        interactive: false,
+        colour: false,
+        ci: false,
+    },
+    {
+        id: `${cockpit}-ci`,
+        fixture: fixtureName(cockpit, "ci", 140, 24),
+        cockpit,
+        axis: "variant",
+        columns: 140,
+        rows: 24,
+        interactive: true,
+        colour: false,
+        ci: true,
+    },
+];
+export const GOLDEN_FRAME_CASES = [
+    ...goldenCasesFor("run"),
+    ...goldenCasesFor("setup"),
+];
+/**
+ * The colour corpus has a deliberately separate manifest from the layout
+ * corpus. Layout cases stay colourless; these cases alone exercise real ink.
+ */
+export const COLOUR_FRAME_CASES = [
+    {
+        id: "healthy-colour",
+        fixture: "run-20260718-000943.colour.140x24.txt",
+        sourceFileName: "run-20260718-000943.journal.jsonl",
+        columns: 140,
+        rows: 24,
+        colour: true,
+    },
+    {
+        id: "healthy-no-colour",
+        fixture: "run-20260718-000943.no-colour.140x24.txt",
+        sourceFileName: "run-20260718-000943.journal.jsonl",
+        columns: 140,
+        rows: 24,
+        colour: false,
+    },
+    {
+        id: "warning-failure-colour",
+        fixture: "run-20260725-025004.interrupted.colour.140x24.txt",
+        sourceFileName: "run-20260725-025004.interrupted.journal.jsonl",
+        columns: 140,
+        rows: 24,
+        colour: true,
+    },
+];
+const COLOUR_SOURCE_DIRECTORY = join(dirname(fileURLToPath(import.meta.url)), "../../../tests/fixtures/cockpit/colour/sources");
+function derivedData(cockpit, binaryVersion, captures) {
+    if (cockpit === "setup") {
+        return {
+            cockpit,
+            data: deriveSetupCockpitData(captures, binaryVersion),
+        };
+    }
+    const source = captures.journals.find((capture) => capture.fileName === "run-20260724-231138.journal.jsonl");
+    if (!source)
+        throw new Error("healthy cockpit capture is missing");
+    return {
+        cockpit,
+        data: deriveRunCockpitData(source, binaryVersion),
+    };
+}
+function stateGlyph(state) {
+    if (state === "active" || state === "pass")
+        return GLYPHS.pass;
+    if (state === "inactive")
+        return GLYPHS.toggleInactive;
+    if (state === "fail")
+        return GLYPHS.fail;
+    if (state === "warn")
+        return GLYPHS.attention;
+    return GLYPHS.neutral;
+}
+function defaultPlainRenderer(cockpit, binaryVersion, captures) {
+    const derived = derivedData(cockpit, binaryVersion, captures);
+    if (derived.cockpit === "run") {
+        const data = derived.data;
+        return [
+            `tickmarkr v${binaryVersion}`,
+            `${data.runId} ${data.status} ${data.elapsed}`,
+            ...data.statusItems.map((item) => `${stateGlyph(item.state)} ${item.text}`),
+            `keys ${KEYBAR_KEYS.run.map((item) => `${item.key} ${item.label}`).join(" · ")}`,
+            "",
+        ].join("\n");
+    }
+    const data = derived.data;
+    return [
+        `tickmarkr v${binaryVersion}`,
+        `setup ${data.counts.found} found ${data.counts.authenticated} authed ${data.counts.routable} routable`,
+        ...data.harnesses.map((harness) => `${stateGlyph(harness.state)} ${harness.stateWord} ${harness.id}`),
+        ...data.deniedChannels.map((denied) => `${GLYPHS.fail} denied ${denied.channel} - ${denied.reason}`),
+        `${GLYPHS.pass} base untouched`,
+        `${GLYPHS.attention} ${data.stagedChanges.length} changes unsaved`,
+        `keys ${KEYBAR_KEYS.setup.map((item) => `${item.key} ${item.label}`).join(" · ")}`,
+        "",
+    ].join("\n");
+}
+function frameNode(derived, columns, rows) {
+    if (derived.cockpit === "run") {
+        return createElement(RunCockpitFrame, {
+            data: derived.data,
+            columns,
+            rows,
+        });
+    }
+    return createElement(SetupCockpitFrame, {
+        data: derived.data,
+        columns,
+        rows,
+    });
+}
+/**
+ * Capture exactly the bytes Ink writes for one static paint. Debug mode is
+ * deliberate: it exposes the complete frame rather than terminal patch
+ * instructions, so the committed corpus is the renderer's frame output.
+ */
+export async function captureRendererOutput(node, options) {
+    const sizedNode = isValidElement(node)
+        && (node.type === RunCockpitFrame || node.type === SetupCockpitFrame)
+        ? cloneElement(node, { rows: options.rows })
+        : node;
+    const output = new PassThrough();
+    output.isTTY = true;
+    output.columns = options.columns;
+    output.rows = options.rows;
+    const writes = [];
+    const write = output.write.bind(output);
+    output.write = ((chunk, ...args) => {
+        writes.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+        return Reflect.apply(write, output, [chunk, ...args]);
+    });
+    const previousColourLevel = chalk.level;
+    const previousNoColour = process.env.NO_COLOR;
+    chalk.level = options.colour ? 3 : 0;
+    if (options.colour)
+        delete process.env.NO_COLOR;
+    else
+        process.env.NO_COLOR = "1";
+    let painted;
+    const firstPaint = new Promise((resolve) => {
+        painted = resolve;
+    });
+    const app = render(sizedNode, {
+        stdout: output,
+        debug: true,
+        patchConsole: false,
+        onRender: painted,
+    });
+    try {
+        await firstPaint;
+        return writes.at(-1) ?? "";
+    }
+    finally {
+        app.unmount();
+        app.cleanup();
+        chalk.level = previousColourLevel;
+        if (previousNoColour === undefined)
+            delete process.env.NO_COLOR;
+        else
+            process.env.NO_COLOR = previousNoColour;
+    }
+}
+/**
+ * The single interactive/plain boundary. It decides before mounting Ink, then
+ * falls back again if a renderer returns an empty paint.
+ */
+export async function captureCockpitOutput(options) {
+    const columns = options.columns ?? options.output.columns ?? 80;
+    const rows = options.rows ?? options.output.rows ?? 24;
+    const interactive = options.interactive
+        ?? options.output.isTTY === true;
+    const colour = options.colour
+        ?? process.env.NO_COLOR === undefined;
+    const ci = options.ci ?? process.env.CI === "true";
+    const captures = options.captures ?? loadDemoCaptures();
+    const plain = () => (options.plainRenderer ?? defaultPlainRenderer)(options.cockpit, options.binaryVersion, captures);
+    const layout = resolveCockpitLayout(columns, rows);
+    if (!interactive || options.output.isTTY !== true || ci || layout.renderer === "plain") {
+        const plainOutput = plain();
+        options.output.write(plainOutput);
+        return { renderer: "plain", output: plainOutput };
+    }
+    const derived = derivedData(options.cockpit, options.binaryVersion, captures);
+    const frameOutput = await (options.frameRenderer ?? captureRendererOutput)(frameNode(derived, columns, rows), { columns, rows, colour });
+    if (frameOutput.length === 0) {
+        const plainOutput = plain();
+        options.output.write(plainOutput);
+        return { renderer: "plain", output: plainOutput };
+    }
+    options.output.write(frameOutput);
+    return { renderer: "frame", output: frameOutput };
+}
+export async function regenerateGoldenFrames(binaryVersion) {
+    const resolvedVersion = binaryVersion ?? await version();
+    const captures = loadDemoCaptures();
+    const regenerated = [];
+    for (const golden of GOLDEN_FRAME_CASES) {
+        const output = new PassThrough();
+        output.isTTY = golden.interactive;
+        output.columns = golden.columns;
+        output.rows = golden.rows;
+        const writes = [];
+        const write = output.write.bind(output);
+        output.write = ((chunk, ...args) => {
+            writes.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+            return Reflect.apply(write, output, [chunk, ...args]);
+        });
+        const emission = await captureCockpitOutput({
+            cockpit: golden.cockpit,
+            output: output,
+            binaryVersion: resolvedVersion,
+            columns: golden.columns,
+            rows: golden.rows,
+            interactive: golden.interactive,
+            colour: golden.colour,
+            ci: golden.ci,
+            captures,
+        });
+        regenerated.push({
+            ...golden,
+            ...emission,
+            emitted: writes.join(""),
+        });
+    }
+    return regenerated;
+}
+export function findGoldenFrameMismatches(regenerated, committed) {
+    const expected = new Set(regenerated.map((frame) => frame.fixture));
+    return [
+        ...regenerated.flatMap((frame) => committed.get(frame.fixture) === frame.output ? [] : [frame.fixture]),
+        ...[...committed.keys()].filter((fixture) => !expected.has(fixture)),
+    ].sort();
+}
+/**
+ * Regenerate only the colour contract corpus from its own manifest. Historical
+ * run sources are read and rendered byte-for-byte with their captured daemon
+ * stopped, matching the demo path and avoiding live-process state in committed
+ * bytes.
+ */
+export async function regenerateColourFrames(binaryVersion) {
+    const resolvedVersion = binaryVersion ?? await version();
+    const regenerated = [];
+    for (const colourCase of COLOUR_FRAME_CASES) {
+        const source = {
+            fileName: colourCase.sourceFileName,
+            raw: readFileSync(join(COLOUR_SOURCE_DIRECTORY, colourCase.sourceFileName), "utf8"),
+        };
+        const data = deriveRunCockpitData(source, resolvedVersion, {
+            isDaemonAlive: () => false,
+        });
+        const output = await captureRendererOutput(frameNode({ cockpit: "run", data }, colourCase.columns, colourCase.rows), {
+            columns: colourCase.columns,
+            rows: colourCase.rows,
+            colour: colourCase.colour,
+        });
+        regenerated.push({
+            ...colourCase,
+            output,
+            emitted: output,
+        });
+    }
+    return regenerated;
+}

package/dist/tui/cockpit/components.d.ts

@@ -0,0 +1,179 @@
+import { type ReactElement, type ReactNode } from "react";
+import { TEXT_EMPHASIS_TOKENS } from "./theme.js";
+export { SPARKLINE_BUCKET_WINDOW } from "./derive.js";
+export declare const PANEL_CHROME_ROWS = 3;
+export declare const BAND_CONTINUATION_PREFIX = "\u21B3 ";
+export type BandColumnContent = {
+    readonly title: string;
+    readonly lines: readonly string[];
+};
+export type BandAllocationOptions = {
+    readonly chromeColumns?: number;
+    readonly minimumReadableColumns?: number;
+};
+export type TextEmphasis = keyof typeof TEXT_EMPHASIS_TOKENS;
+export type ComponentState = "active" | "inactive" | "pass" | "fail" | "warn" | "neutral";
+export type KeybarSurface = "run" | "setup";
+export type KeybarItem = {
+    readonly key: string;
+    readonly label: string;
+};
+export declare const KEYBAR_KEYS: {
+    readonly run: readonly [{
+        readonly key: "↑↓";
+        readonly label: "Move";
+    }, {
+        readonly key: "⏎";
+        readonly label: "Open";
+    }, {
+        readonly key: "←";
+        readonly label: "Back";
+    }, {
+        readonly key: "Tab";
+        readonly label: "Panel";
+    }, {
+        readonly key: "?";
+        readonly label: "Help";
+    }, {
+        readonly key: "q";
+        readonly label: "Quit";
+    }, {
+        readonly key: "f";
+        readonly label: "Follow";
+    }, {
+        readonly key: "/";
+        readonly label: "Filter";
+    }];
+    readonly setup: readonly [{
+        readonly key: "↑↓";
+        readonly label: "Move";
+    }, {
+        readonly key: "⏎";
+        readonly label: "Next";
+    }, {
+        readonly key: "←";
+        readonly label: "Back";
+    }, {
+        readonly key: "Tab";
+        readonly label: "Panel";
+    }, {
+        readonly key: "?";
+        readonly label: "Help";
+    }, {
+        readonly key: "q";
+        readonly label: "Quit";
+    }, {
+        readonly key: "␣";
+        readonly label: "Toggle";
+    }, {
+        readonly key: "a";
+        readonly label: "All";
+    }, {
+        readonly key: "r";
+        readonly label: "Re-probe";
+    }, {
+        readonly key: "s";
+        readonly label: "Save";
+    }, {
+        readonly key: "n";
+        readonly label: "Next";
+    }, {
+        readonly key: "p";
+        readonly label: "Prev";
+    }];
+    readonly setupAdditional: readonly [{
+        readonly key: "␣";
+        readonly label: "Toggle";
+    }, {
+        readonly key: "a";
+        readonly label: "All";
+    }, {
+        readonly key: "r";
+        readonly label: "Re-probe";
+    }, {
+        readonly key: "s";
+        readonly label: "Save";
+    }, {
+        readonly key: "n";
+        readonly label: "Next";
+    }, {
+        readonly key: "p";
+        readonly label: "Prev";
+    }];
+};
+export type JournalRow = {
+    readonly id?: string;
+    readonly time: string;
+    readonly state: ComponentState;
+    readonly text: string;
+};
+export declare function BodyText({ children, emphasis, }: {
+    children: ReactNode;
+    emphasis?: TextEmphasis;
+}): ReactElement;
+/**
+ * Give each panel the columns its own longest line calls for. Surplus is shared
+ * evenly after every line fits; scarcity is apportioned by unmet content need.
+ */
+export declare function allocateBandColumns(columns: number, content: readonly BandColumnContent[], options?: BandAllocationOptions): readonly number[];
+/**
+ * Compose one data line into visible rows. A fitting line is byte-for-byte
+ * untouched. Every wrapped row carries a continuation marker before any
+ * separator or data token, so it cannot masquerade as a new item.
+ */
+export declare function composeBandLine(text: string, columns: number): readonly string[];
+export declare function BandLines({ lines, columns, emphasis, }: {
+    lines: readonly string[];
+    columns: number;
+    emphasis?: TextEmphasis;
+}): ReactElement;
+/** Rows drawn by a band of bordered panels at the same allocated widths. */
+export declare function measureBandRows(columns: number, content: readonly BandColumnContent[]): number;
+export declare function StateGlyph({ state }: {
+    state: ComponentState;
+}): ReactElement;
+export declare function Panel({ title, focused, width, flexGrow, children, }: {
+    title: string;
+    focused?: boolean;
+    width?: number | string;
+    flexGrow?: number;
+    children: ReactNode;
+}): ReactElement;
+export declare function CockpitGrid({ children, columns, columnContents, allocation, }: {
+    children: ReactNode;
+    columns?: number;
+    columnContents?: readonly BandColumnContent[];
+    allocation?: BandAllocationOptions;
+}): ReactElement;
+export declare function Sparkline({ samples, }: {
+    samples: readonly (number | null)[];
+}): ReactElement;
+export declare function StatTile({ label, value, samples, focused, width, }: {
+    label: string;
+    value: ReactNode;
+    samples: readonly (number | null)[];
+    focused?: boolean;
+    width?: number | string;
+}): ReactElement;
+export declare function ProgressMeter({ value, width, }: {
+    value: number;
+    width?: number;
+}): ReactElement;
+export declare function Keybar({ surface, width, }: {
+    surface: KeybarSurface;
+    width: number;
+}): ReactElement;
+export type StatusStripItem = {
+    readonly state: ComponentState;
+    readonly text: string;
+};
+export declare function StatusStrip({ items, width, }: {
+    items: readonly StatusStripItem[];
+    width: number;
+}): ReactElement;
+export declare function JournalRowPanel({ rows, width, focused, title, }: {
+    rows: readonly JournalRow[];
+    width?: number | string;
+    focused?: boolean;
+    title?: string;
+}): ReactElement;