@voidlabs.gg/voidshift 0.0.0-stage → 0.4.1

package/dist/tui/screens/memory.js

@@ -0,0 +1,174 @@
+// Memory: the vault, what is not indexed, and recall per config folder. Try
+// and check run the real commands (vsf memory try / check --json); on and off
+// run vsf memory on|off DIR.
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import { runAction } from "../actions.js";
+import { useData } from "../data.js";
+import { useBackGuard, useEquivalent, useHints, useKeys, useScreen } from "../context.js";
+import { clockOrStamp, plural, tilde, truncate } from "../format.js";
+import { theme } from "../theme.js";
+import { Lines, Panel, seg, TextInput } from "../widgets.js";
+import { scrollBy } from "./list-window.js";
+const h = React.createElement;
+export const kindLabel = (k) => (k === 'codex' ? 'Codex' : 'Claude Code');
+export function recallText(recall) {
+    if (recall === 'on')
+        return { text: 'recall on', colour: theme.green };
+    if (recall === 'other')
+        return { text: 'another hook recalls', colour: theme.yellow };
+    return { text: 'recall off', colour: theme.dim };
+}
+// vsf memory on|off DIR for the chosen home.
+export const toggleArgs = (mode, home) => ['memory', mode, home.dir];
+export const tryArgs = (prompt) => ['memory', 'try', ...(prompt.startsWith('-') ? ['--'] : []), prompt];
+export function parseProblems(output) {
+    try {
+        const v = JSON.parse(output);
+        return { unindexed: v.unindexed ?? [], brokenIndex: v.brokenIndex ?? [], brokenLinks: v.brokenLinks ?? [] };
+    }
+    catch {
+        return null;
+    }
+}
+// The problems grouped as the check command groups them.
+export function problemLines(p) {
+    const lines = [];
+    const group = (title, items) => {
+        if (!items.length)
+            return;
+        lines.push([seg(`${title} (${items.length})`, theme.yellow)]);
+        for (const i of items)
+            lines.push([seg(`  ${i}`)]);
+    };
+    group('Not in INDEX.md, never recalled', p.unindexed);
+    group('INDEX.md links to files that do not exist', p.brokenIndex);
+    group('[[links]] that match no note', p.brokenLinks.map((l) => `${l.note}: [[${l.link}]]`));
+    if (!lines.length)
+        lines.push([seg('Vault looks good. Every note is indexed and every link works.', theme.green)]);
+    return lines;
+}
+export function vaultLines(m, now = new Date()) {
+    const label = (t) => seg(t.padEnd(14), theme.dim);
+    const lines = [[label('Vault'), seg(tilde(m.vault))]];
+    if (!m.isVault) {
+        lines.push([seg('This folder has no INDEX.md, so it is not a vault yet. Run vsf setup memory.', theme.yellow)]);
+        return lines;
+    }
+    lines.push([label('Notes'), seg(`${m.notes}`), seg(`  ${m.indexed} in INDEX.md`, theme.dim)]);
+    lines.push([label('Last updated'), seg(m.lastUpdated ? clockOrStamp(new Date(m.lastUpdated), now) : 'never')]);
+    if (m.unindexed.count) {
+        const names = m.unindexed.names.slice(0, 5).map((n) => truncate(n, 40));
+        lines.push([label('Not indexed'), seg(plural(m.unindexed.count, 'note'), theme.yellow), seg('  never recalled. c shows the details', theme.dim)]);
+        for (const n of names)
+            lines.push([seg(`  ${n}`, theme.dim)]);
+        if (m.unindexed.count > names.length)
+            lines.push([seg(`  +${m.unindexed.count - names.length} more`, theme.dim)]);
+    }
+    else
+        lines.push([label('Not indexed'), seg('none', theme.green)]);
+    return lines;
+}
+function Memory() {
+    const ctx = useScreen();
+    const { state } = useData();
+    const m = state.memory;
+    const [sel, setSel] = useState(0);
+    const [asking, setAsking] = useState(false);
+    const [prompt, setPrompt] = useState('');
+    const [result, setResult] = useState(null);
+    const [offset, setOffset] = useState(0);
+    const [busy, setBusy] = useState(false);
+    const homes = m?.homes ?? [];
+    const at = Math.min(sel, Math.max(0, homes.length - 1));
+    const home = homes[at];
+    useBackGuard(() => {
+        if (asking) {
+            setAsking(false);
+            return true;
+        }
+        if (result) {
+            setResult(null);
+            return true;
+        }
+        return false;
+    });
+    useHints(asking
+        ? [{ key: 'enter', label: 'try it' }, { key: 'esc', label: 'cancel' }]
+        : [{ key: 't', label: 'try a prompt' }, { key: 'c', label: 'check' }, { key: 'o', label: 'recall on' }, { key: 'f', label: 'recall off' }, { key: 'esc', label: 'back' }]);
+    useEquivalent(asking ? tryArgs(prompt || 'PROMPT') : ['memory', 'status']);
+    const runRead = async (args, title, shape) => {
+        if (busy)
+            return;
+        setBusy(true);
+        ctx.toast(`Running vsf ${args.join(' ')}`, 'info');
+        const r = await runAction(args, { timeoutMs: 60_000 });
+        setBusy(false);
+        setOffset(0);
+        setResult({ title, lines: shape(r.output, r.code) });
+    };
+    const submitTry = (value) => {
+        const p = value.trim();
+        if (!p)
+            return;
+        setAsking(false);
+        void runRead(tryArgs(p), `vsf memory try`, (out) => (out ? out.split('\n').map((l) => [seg(l)]) : [[seg('Nothing would be recalled.', theme.dim)]]));
+    };
+    useKeys((input, key) => {
+        if (asking) {
+            if (key.escape)
+                setAsking(false);
+            return;
+        }
+        if (key.upArrow)
+            setSel(Math.max(0, at - 1));
+        else if (key.downArrow)
+            setSel(Math.min(homes.length - 1, at + 1));
+        else if (key.pageUp)
+            setOffset((o) => scrollBy(o, -8, 10000));
+        else if (key.pageDown)
+            setOffset((o) => scrollBy(o, 8, 10000));
+        else if (input === 't') {
+            setPrompt('');
+            setAsking(true);
+        }
+        else if (input === 'c') {
+            void runRead(['memory', 'check', '--json'], 'vsf memory check', (out, code) => {
+                const p = parseProblems(out);
+                return p ? problemLines(p) : [[seg(out || `Check failed (exit code ${code})`, theme.red)]];
+            });
+        }
+        else if ((input === 'o' || input === 'f') && home) {
+            const mode = input === 'o' ? 'on' : 'off';
+            void ctx.actions.run({
+                args: toggleArgs(mode, home),
+                title: `Turn recall ${mode} in ${kindLabel(home.kind)}?`,
+                body: mode === 'on'
+                    ? `Adds the recall hook to ${tilde(home.dir)}, so matching notes are added to your prompts.`
+                    : `Removes the recall hook from ${tilde(home.dir)}. The skill stays.`,
+                confirmLabel: `Turn ${mode}`,
+                cancelLabel: 'Leave it',
+            });
+        }
+    }, { whileCapturing: true });
+    if (!m) {
+        return h(Box, { paddingX: 1 }, h(Text, { color: state.errors.memory ? theme.red : theme.dim }, state.errors.memory ?? (state.loaded ? 'memory is not added. Run vsf add memory.' : 'Loading...')));
+    }
+    const size = Math.max(4, ctx.rows - 20);
+    return h(Box, { flexDirection: 'column' }, h(Panel, { title: 'Memory' }, h(Lines, { lines: vaultLines(m) })), h(Panel, { title: 'Config folders', focused: !result && !asking }, homes.length === 0 ? h(Text, { color: theme.dim }, 'No config folders saved. Run vsf setup memory.') : null, ...homes.map((hm, i) => {
+        const r = recallText(hm.recall);
+        const on = i === at;
+        const bg = on ? theme.selected : undefined;
+        return h(Box, { key: hm.dir, flexDirection: 'row' }, h(Text, { backgroundColor: bg, color: theme.accent }, on ? '▶ ' : '  '), h(Text, { backgroundColor: bg, bold: on }, kindLabel(hm.kind).padEnd(13)), h(Text, { backgroundColor: bg, color: theme.dim }, tilde(hm.dir).padEnd(24)), h(Text, { backgroundColor: bg, color: r.colour }, r.text.padEnd(22)), h(Text, { backgroundColor: bg, color: theme.dim }, `skill ${hm.skill}`));
+    })), asking
+        ? h(Panel, { title: 'Try a prompt', focused: true }, h(Text, { color: theme.dim }, 'Type a prompt to see what recall would add to it. Real sessions are not touched.'), h(TextInput, { value: prompt, onChange: setPrompt, onSubmit: submitTry, placeholder: 'e.g. how do we deploy the relay?' }))
+        : null, result
+        ? h(Panel, { title: result.title, subtitle: 'esc closes', focused: true }, h(Lines, { lines: result.lines.slice(offset, offset + size) }), result.lines.length > offset + size ? h(Text, { color: theme.dim }, `+${result.lines.length - offset - size} more lines, page down`) : null)
+        : null);
+}
+export const memoryScreen = {
+    id: 'memory',
+    title: 'Memory',
+    component: () => h(Memory),
+    hints: () => [{ key: 't', label: 'try a prompt' }, { key: 'c', label: 'check' }, { key: 'o', label: 'recall on' }, { key: 'f', label: 'recall off' }, { key: 'esc', label: 'back' }],
+};

package/dist/tui/screens/project-form.d.ts

@@ -0,0 +1,14 @@
+import type { Screen } from '../screens.ts';
+export type ProjectField = 'name' | 'path' | 'base';
+export interface ProjectDraft {
+    name: string;
+    path: string;
+    base: string;
+}
+export declare function expandPath(p: string, home?: string): string;
+export declare function repoState(path: string, exists?: (p: string) => boolean): 'ok' | 'empty' | 'not-repo';
+export declare function projectProblems(d: ProjectDraft, isNew: boolean, existing: string[], exists?: (p: string) => boolean): string[];
+export declare function projectSaveArgs(d: ProjectDraft, isNew: boolean): string[];
+export declare const fieldsFor: (isNew: boolean) => ProjectField[];
+export declare function moveFocus(fields: ProjectField[], current: ProjectField, delta: number): ProjectField;
+export declare const projectFormScreen: Screen;

package/dist/tui/screens/project-form.js

@@ -0,0 +1,137 @@
+// The project form: Name, Path, Base branch. Saves with
+// `vsf agents project add|edit`, run as a child process.
+import React, { useState } from 'react';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { Box, Text } from 'ink';
+import { useData } from "../data.js";
+import { useBackGuard, useEquivalent, useHints, useKeys, useScreen } from "../context.js";
+import { theme } from "../theme.js";
+import { Panel, TextInput } from "../widgets.js";
+const h = React.createElement;
+export function expandPath(p, home = homedir()) {
+    const t = p.trim();
+    if (t === '~')
+        return home;
+    if (t.startsWith('~/'))
+        return join(home, t.slice(2));
+    return t ? resolve(t) : t;
+}
+// ok: a git repository. missing: nothing typed yet. not-repo: anything else.
+export function repoState(path, exists = existsSync) {
+    if (!path.trim())
+        return 'empty';
+    return exists(join(expandPath(path), '.git')) ? 'ok' : 'not-repo';
+}
+export function projectProblems(d, isNew, existing, exists) {
+    const out = [];
+    if (isNew) {
+        if (!d.name.trim())
+            out.push('Give the project a name.');
+        else if (existing.includes(d.name.trim()))
+            out.push(`A project named ${d.name.trim()} already exists.`);
+    }
+    const r = repoState(d.path, exists);
+    if (r === 'empty')
+        out.push('Give the path to a git repository.');
+    else if (r === 'not-repo')
+        out.push('That path is not a git repository.');
+    return out;
+}
+export function projectSaveArgs(d, isNew) {
+    const name = d.name.trim();
+    const path = d.path.trim();
+    const base = d.base.trim();
+    if (isNew)
+        return ['agents', 'project', 'add', name, '--path', path, ...(base ? ['--base', base] : [])];
+    // An empty --base on edit clears it, so PRs go to the repo's default branch.
+    return ['agents', 'project', 'edit', name, '--path', path, '--base', base];
+}
+export const fieldsFor = (isNew) => (isNew ? ['name', 'path', 'base'] : ['path', 'base']);
+export function moveFocus(fields, current, delta) {
+    const i = Math.max(0, fields.indexOf(current));
+    return fields[(i + delta + fields.length) % fields.length];
+}
+const KEY_HINTS = [
+    { key: 'tab', label: 'next field' },
+    { key: 'ctrl+s', label: 'save' },
+    { key: 'esc', label: 'discard' },
+];
+function Row(props) {
+    return h(Box, { flexDirection: 'column' }, h(Box, null, h(Box, { width: 14, flexShrink: 0 }, h(Text, { bold: props.focused, color: props.focused ? theme.accent : theme.text }, props.label)), h(Box, { flexGrow: 1 }, props.children)), props.note ? h(Box, { paddingLeft: 14 }, props.note) : null);
+}
+function ProjectForm(props) {
+    const ctx = useScreen();
+    const { state } = useData();
+    const origName = typeof props.params.name === 'string' ? props.params.name : null;
+    const isNew = origName === null;
+    const [initial] = useState(() => {
+        const p = origName ? state.projects.find((x) => x.name === origName) : undefined;
+        return { name: origName ?? '', path: p?.path ?? '', base: p?.base ?? '' };
+    });
+    const [draft, setDraft] = useState(initial);
+    const fields = fieldsFor(isNew);
+    const [focus, setFocus] = useState(fields[0]);
+    const [attempted, setAttempted] = useState(false);
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(null);
+    const dirty = JSON.stringify(draft) !== JSON.stringify(initial);
+    const problems = projectProblems(draft, isNew, state.projects.map((p) => p.name));
+    const args = projectSaveArgs(draft, isNew);
+    const set = (key) => (value) => setDraft((d) => ({ ...d, [key]: value }));
+    const repo = repoState(draft.path);
+    useHints(KEY_HINTS);
+    useEquivalent(draft.name.trim() ? args : null);
+    useBackGuard(() => true);
+    const save = async () => {
+        if (busy)
+            return;
+        if (problems.length) {
+            setAttempted(true);
+            return;
+        }
+        setBusy(true);
+        setError(null);
+        const r = await ctx.actions.run({ args, title: 'Save project', noConfirm: true, done: `Saved ${draft.name.trim()}` });
+        setBusy(false);
+        if (r && r.code === 0)
+            ctx.nav.pop();
+        else if (r)
+            setError(r.output || `vsf exited with code ${r.code}`);
+    };
+    const discard = async () => {
+        if (dirty) {
+            const ok = await ctx.actions.confirm({ title: 'Discard changes?', body: 'What you typed here will be lost.', confirmLabel: 'Discard', cancelLabel: 'Keep editing' });
+            if (!ok)
+                return;
+        }
+        ctx.nav.pop();
+    };
+    useKeys((input, key) => {
+        if (key.escape)
+            void discard();
+        else if (key.ctrl && input === 's')
+            void save();
+        else if (key.tab)
+            setFocus((f) => moveFocus(fields, f, key.shift ? -1 : 1));
+        else if (key.downArrow)
+            setFocus((f) => moveFocus(fields, f, 1));
+        else if (key.upArrow)
+            setFocus((f) => moveFocus(fields, f, -1));
+    }, { whileCapturing: true });
+    const pathNote = repo === 'ok'
+        ? h(Text, { color: theme.green }, 'git repository')
+        : repo === 'not-repo'
+            ? h(Text, { color: theme.red }, 'Not a git repository (no .git in that folder)')
+            : h(Text, { color: theme.dim }, 'Where the repo lives, like ~/me/tether/tether-relay');
+    return h(Panel, { title: isNew ? 'New project' : 'Edit project', focused: true }, isNew
+        ? h(Row, { label: 'Name', focused: focus === 'name' }, h(TextInput, { value: draft.name, onChange: set('name'), focus: focus === 'name', placeholder: 'tether-relay' }))
+        : h(Row, { label: 'Name', focused: false }, h(Text, null, draft.name), h(Text, { color: theme.dim }, '   R on the list renames it')), h(Text, null, ' '), h(Row, { label: 'Path', focused: focus === 'path', note: pathNote }, h(TextInput, { value: draft.path, onChange: set('path'), focus: focus === 'path', placeholder: '~/me/repo' })), h(Text, null, ' '), h(Row, { label: 'Base branch', focused: focus === 'base', note: h(Text, { color: theme.dim }, 'Pull requests go into this branch. Empty means the repo default.') }, h(TextInput, { value: draft.base, onChange: set('base'), focus: focus === 'base', placeholder: 'default branch' })), attempted && problems.length ? h(Box, { flexDirection: 'column', marginTop: 1 }, ...problems.map((p, i) => h(Text, { key: i, color: theme.red }, `! ${p}`))) : null, error ? h(Box, { marginTop: 1 }, h(Text, { color: theme.red }, error)) : null, busy ? h(Text, { color: theme.dim }, 'Saving...') : null);
+}
+export const projectFormScreen = {
+    id: 'agents.project.form',
+    title: (p) => ['Projects', typeof p.name === 'string' ? `Edit ${p.name}` : 'New project'],
+    component: (props) => h(ProjectForm, { params: props.params }),
+    hints: () => KEY_HINTS,
+};

package/dist/tui/screens/projects.d.ts

@@ -0,0 +1,17 @@
+import { type ProjectItem } from '../data.ts';
+import { type Column } from '../widgets.ts';
+import type { Screen } from '../screens.ts';
+export declare const baseText: (p: Pick<ProjectItem, "base">) => string;
+export declare const usedByText: (p: Pick<ProjectItem, "usedBy">) => string;
+export declare function projectRows(projects: ProjectItem[]): (string | {
+    text: string;
+    bold: boolean;
+    colour?: undefined;
+} | {
+    text: string;
+    colour: "#6b7280";
+    bold?: undefined;
+})[][];
+export declare function projectColumns(columns: number, projects?: ProjectItem[]): Column[];
+export declare function deleteBlock(p: ProjectItem): string | null;
+export declare const projectsScreen: Screen;

package/dist/tui/screens/projects.js

@@ -0,0 +1,109 @@
+// Agents, Projects: the repos the workflows run in.
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import { useData } from "../data.js";
+import { useEquivalent, useHints, useKeys, useScreen } from "../context.js";
+import { tilde } from "../format.js";
+import { theme } from "../theme.js";
+import { Panel, Table, TextInput } from "../widgets.js";
+const h = React.createElement;
+export const baseText = (p) => p.base ?? 'default branch';
+export const usedByText = (p) => (p.usedBy?.length ? `used by ${p.usedBy.join(', ')}` : 'not used');
+export function projectRows(projects) {
+    return projects.map((p) => [{ text: p.name, bold: true }, tilde(p.path), `PRs into ${baseText(p)}`, { text: usedByText(p), colour: theme.dim }]);
+}
+export function projectColumns(columns, projects = []) {
+    const fit = (min, texts, max) => Math.min(max, Math.max(min, ...texts.map((t) => t.length + 2)));
+    const name = fit(12, projects.map((p) => p.name), 26);
+    const base = fit(18, projects.map((p) => `PRs into ${baseText(p)}`), 30);
+    const path = Math.min(fit(16, projects.map((p) => tilde(p.path)), 48), Math.max(16, columns - 12 - 2 - name - base - 24));
+    return [{ title: 'Name', width: name }, { title: 'Path', width: path }, { title: 'Base', width: base }, { title: 'Used by' }];
+}
+// Why a project cannot be deleted, or null when it can (the command refuses the same way).
+export function deleteBlock(p) {
+    return p.usedBy?.length ? `${p.name} is used by ${p.usedBy.join(', ')}. Change or delete those workflows first.` : null;
+}
+const LIST_HINTS = [
+    { key: 'n', label: 'new' },
+    { key: 'e', label: 'edit' },
+    { key: 'R', label: 'rename' },
+    { key: 'd', label: 'delete' },
+    { key: 'esc', label: 'back' },
+];
+function Projects() {
+    const ctx = useScreen();
+    const { state } = useData();
+    const list = state.projects;
+    const [selName, setSelName] = useState(null);
+    const [renaming, setRenaming] = useState(null);
+    const [draft, setDraft] = useState('');
+    const found = list.findIndex((p) => p.name === selName);
+    const index = found >= 0 ? found : Math.min(0, list.length - 1);
+    const selected = list[index];
+    useHints(renaming !== null ? [{ key: 'enter', label: 'rename' }, { key: 'esc', label: 'cancel' }] : LIST_HINTS);
+    useEquivalent(renaming !== null && draft.trim() && draft.trim() !== renaming ? ['agents', 'project', 'rename', renaming, draft.trim()] : null);
+    const rename = async () => {
+        const next = draft.trim();
+        if (renaming === null)
+            return;
+        if (!next || next === renaming) {
+            setRenaming(null);
+            return;
+        }
+        if (list.some((p) => p.name === next)) {
+            ctx.toast(`A project named ${next} already exists.`, 'error');
+            return;
+        }
+        const r = await ctx.actions.run({ args: ['agents', 'project', 'rename', renaming, next], title: 'Rename project', noConfirm: true, done: `Renamed to ${next}` });
+        if (r && r.code === 0)
+            setSelName(next);
+        if (r)
+            setRenaming(null);
+    };
+    useKeys((input, key) => {
+        if (renaming !== null) {
+            if (key.escape)
+                setRenaming(null);
+            return;
+        }
+        if (key.upArrow || input === 'k')
+            setSelName(list[Math.max(0, index - 1)]?.name ?? null);
+        else if (key.downArrow || input === 'j')
+            setSelName(list[Math.min(list.length - 1, index + 1)]?.name ?? null);
+        else if (input === 'n')
+            ctx.nav.push('agents.project.form', {});
+        else if ((input === 'e' || key.return) && selected)
+            ctx.nav.push('agents.project.form', { name: selected.name });
+        else if (input === 'R' && selected) {
+            setDraft(selected.name);
+            setRenaming(selected.name);
+        }
+        else if (input === 'd' && selected) {
+            const block = deleteBlock(selected);
+            if (block)
+                ctx.toast(block, 'error');
+            else
+                void ctx.actions.run({
+                    args: ['agents', 'project', 'rm', selected.name, '--yes'],
+                    title: `Delete project ${selected.name}?`,
+                    body: 'Only the entry is removed. The repo on disk is not touched.',
+                    confirmLabel: 'Delete',
+                    done: `Deleted ${selected.name}`,
+                });
+        }
+    }, { whileCapturing: true });
+    return h(Panel, { title: 'Projects', focused: true }, h(Text, { color: theme.dim }, 'Repos on this Mac where agents do the work.'), h(Text, null, ' '), h(Table, {
+        columns: projectColumns(ctx.columns, list),
+        rows: projectRows(list),
+        selected: index,
+        empty: state.loaded ? 'No projects yet. Press n to add one.' : 'Loading...',
+    }), renaming !== null
+        ? h(Box, { marginTop: 1 }, h(Text, { color: theme.dim }, `Rename ${renaming} to  `), h(TextInput, { value: draft, onChange: setDraft, onSubmit: () => void rename() }))
+        : null, state.errors.projects ? h(Text, { color: theme.red }, state.errors.projects) : null);
+}
+export const projectsScreen = {
+    id: 'agents.projects',
+    title: 'Projects',
+    component: Projects,
+    hints: () => LIST_HINTS,
+};

package/dist/tui/screens/runs.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import { type Key } from 'ink';
+import { type ActionSpec, type Hint } from '../context.ts';
+import { type DataState, type RunItem, type StepRecord } from '../data.ts';
+import { type Line } from '../widgets.ts';
+import type { Screen } from '../screens.ts';
+export declare const manualLogPath: (dir: string) => string;
+export declare const tabLock: {
+    on: boolean;
+};
+export declare function filterRuns(runs: RunItem[], text: string): RunItem[];
+export declare function stepsLabel(steps: StepRecord[]): string;
+export declare function roundsOf(steps: StepRecord[]): number;
+export declare function runMs(run: RunItem, nowMs: number): number | null;
+export declare function outcomeOf(run: RunItem, state: Pick<DataState, 'agents'>): string;
+export declare function isLive(run: RunItem | undefined, state: Pick<DataState, 'agents'>): boolean;
+export declare function startedText(run: RunItem): string;
+export declare function settledSteps(run: RunItem, state: Pick<DataState, 'agents'>): StepRecord[];
+export declare function stepMark(step: StepRecord): {
+    glyph: string;
+    colour: string;
+};
+export declare const stepResult: (step: StepRecord) => string;
+export declare function stepMs(step: StepRecord, nowMs: number): number | null;
+export declare const stepDuration: (step: StepRecord, nowMs: number) => string;
+export declare function stepLine(step: StepRecord, nowMs: number): Line;
+export declare function windowStart(total: number, selected: number, size: number, start: number): number;
+export interface RunsKeys {
+    action: 'open' | 'cancel' | 'retry' | 'from' | 'clean' | 'filter' | 'up' | 'down' | null;
+}
+export declare function runsKey(input: string, key: Partial<Key>): RunsKeys['action'];
+export declare function cancelSpec(card: string, stepLabel?: string): ActionSpec;
+export declare const RUN_HINTS: Hint[];
+export declare function logStepOf(run: RunItem): StepRecord | undefined;
+export declare function fetchLabelsReal(card: string): Promise<string[] | null>;
+export declare const runsDeps: {
+    fetchLabels: typeof fetchLabelsReal;
+    debounceMs: number;
+};
+export declare function Runs(props: {
+    params: Record<string, unknown>;
+}): React.ReactElement;
+export declare const runsScreen: Screen;