@north-light/crouter 0.3.236 → 0.3.238

package/dist/commands/sys/context/admin/axes-panel.js

@@ -0,0 +1,117 @@
+// The snapshot rail: the configuration axes the page plans against. Every row
+// is a live control — an enum cycles in place, a free-text axis opens a field —
+// and every change re-plans the whole surface.
+import { truncateToWidth } from '@earendil-works/pi-tui';
+import { padAnsi, theme, visibleRange } from '../../../../core/tui/panel.js';
+import { SURFACE_EVENTS } from '../../../../core/substrate/schema.js';
+import { listProfiles } from '../../../../core/profiles/manifest.js';
+import { payloadAxisFor } from './model.js';
+function tildify(path) {
+    const home = process.env['HOME'];
+    return home !== undefined && home !== '' && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+/** The rail's rows for a snapshot. The payload row appears only for the events
+ *  that read one, because on boot there is nothing it could change. */
+export function axesOf(snapshot, profileName) {
+    const payload = payloadAxisFor(snapshot.event);
+    const payloadValue = payload === 'file' ? snapshot.file : payload === 'docName' ? snapshot.docName : payload === 'command' ? snapshot.command : '';
+    return [
+        { id: 'event', label: 'event', value: snapshot.event, typed: false },
+        ...(payload === null
+            ? []
+            : [{
+                    id: 'payload',
+                    label: payload === 'file' ? 'file' : payload === 'docName' ? 'doc' : 'command',
+                    value: payloadValue === '' ? '(none — nothing matches)' : payloadValue,
+                    typed: true,
+                }]),
+        { id: 'kind', label: 'kind', value: snapshot.kind, typed: true },
+        { id: 'mode', label: 'mode', value: snapshot.mode, typed: false },
+        { id: 'lifecycle', label: 'lifecycle', value: snapshot.lifecycle, typed: false },
+        { id: 'manager', label: 'manager', value: snapshot.hasManager ? 'yes' : 'no', typed: false },
+        { id: 'depth', label: 'depth', value: String(snapshot.depth), typed: false },
+        { id: 'profile', label: 'profile', value: profileName, typed: false },
+        { id: 'cwd', label: 'cwd', value: tildify(snapshot.cwd), typed: true },
+    ];
+}
+/** Cycle one enum axis, returning the changed snapshot. A typed axis is never
+ *  cycled — the shell opens a field for it instead. */
+export function cycleAxis(snapshot, id, delta) {
+    const step = (values, current) => {
+        const at = values.indexOf(current);
+        return values[(Math.max(0, at) + delta + values.length) % values.length];
+    };
+    switch (id) {
+        case 'event':
+            return { ...snapshot, event: step(SURFACE_EVENTS, snapshot.event) };
+        case 'mode': {
+            const mode = step(['base', 'orchestrator'], snapshot.mode);
+            // Lifecycle follows mode the way node creation defaults it, so cycling to
+            // orchestrator does not leave a resident-only persona reading as terminal.
+            return { ...snapshot, mode, lifecycle: mode === 'orchestrator' ? 'resident' : 'terminal' };
+        }
+        case 'lifecycle':
+            return { ...snapshot, lifecycle: step(['terminal', 'resident'], snapshot.lifecycle) };
+        case 'manager':
+            return { ...snapshot, hasManager: !snapshot.hasManager };
+        case 'depth':
+            return { ...snapshot, depth: Math.max(0, snapshot.depth + delta) };
+        case 'profile': {
+            const ids = [null, ...listProfiles().map((entry) => entry.profileId)];
+            return { ...snapshot, profileId: step(ids, snapshot.profileId) };
+        }
+        default:
+            return snapshot;
+    }
+}
+/** Apply a typed axis's submitted value. */
+export function setTypedAxis(snapshot, id, value) {
+    const trimmed = value.trim();
+    if (id === 'kind')
+        return trimmed === '' ? snapshot : { ...snapshot, kind: trimmed };
+    if (id === 'cwd')
+        return trimmed === '' ? snapshot : { ...snapshot, cwd: trimmed };
+    if (id !== 'payload')
+        return snapshot;
+    const axis = payloadAxisFor(snapshot.event);
+    if (axis === 'file')
+        return { ...snapshot, file: trimmed };
+    if (axis === 'docName')
+        return { ...snapshot, docName: trimmed };
+    if (axis === 'command')
+        return { ...snapshot, command: trimmed };
+    return snapshot;
+}
+/** The value a typed axis's field is seeded with. */
+export function typedAxisValue(snapshot, id) {
+    if (id === 'kind')
+        return snapshot.kind;
+    if (id === 'cwd')
+        return snapshot.cwd;
+    const axis = payloadAxisFor(snapshot.event);
+    return axis === 'file' ? snapshot.file : axis === 'docName' ? snapshot.docName : axis === 'command' ? snapshot.command : '';
+}
+const LABEL_WIDTH = 10;
+export function renderAxes(axes, index, width, height, focused) {
+    const out = [theme.fg('dim', ' SNAPSHOT'), ''];
+    const headerRows = out.length;
+    const rows = [];
+    for (const [at, axis] of axes.entries()) {
+        const room = Math.max(1, width - LABEL_WIDTH - 2);
+        const label = padAnsi(truncateToWidth(axis.label, LABEL_WIDTH), LABEL_WIDTH);
+        const value = truncateToWidth(axis.value, room);
+        const body = ` ${label} ${value}`;
+        if (at === index && focused)
+            rows.push(theme.bg('selectedBg', padAnsi(body, width)));
+        else if (at === index)
+            rows.push(`${theme.fg('accent', '▌')}${padAnsi(theme.fg('accent', body.slice(1)), width - 1)}`);
+        else
+            rows.push(padAnsi(` ${theme.fg('dim', label)} ${value}`, width));
+    }
+    const capacity = Math.max(1, height - headerRows);
+    const range = visibleRange(rows.length, index, capacity);
+    out.push(...rows.slice(range.start, range.start + capacity));
+    while (out.length < height)
+        out.push('');
+    return out.slice(0, height);
+}

package/dist/commands/sys/context/admin/detail-panel.d.ts

@@ -0,0 +1,53 @@
+import { type Rung, type SurfaceEvent } from '../../../../core/substrate/schema.js';
+import type { DeliveryRecord } from '../../../../core/substrate/plan.js';
+import type { DocRow } from './docs-panel.js';
+/** A field of the focused document the shell can write. `entry` carries an
+ *  index into the document's whole surfaces list, not the focused event's
+ *  subset, because that list is what a write replaces. */
+export type DetailRow = {
+    kind: 'entry';
+    at: number;
+} | {
+    kind: 'add-entry';
+} | {
+    kind: 'gate';
+} | {
+    kind: 'unlisted';
+} | {
+    kind: 'slash';
+} | {
+    kind: 'routing';
+} | {
+    kind: 'short-form';
+} | {
+    kind: 'body';
+} | {
+    kind: 'cap';
+} | {
+    kind: 'move';
+};
+export interface CapOwner {
+    path: string;
+    memory: Rung;
+}
+export declare class ContextDetailPanel {
+    private row;
+    private event;
+    private capOwner;
+    private readOnly;
+    private rows;
+    private index;
+    /** Lines scrolled past the cursor's own window, so the verdict below the last
+     *  editable row stays reachable. */
+    private tail;
+    setContext(row: DocRow | undefined, event: SurfaceEvent, capOwner: CapOwner | null, readOnly: string | null): void;
+    get selected(): DetailRow | undefined;
+    /** The entry index a rung cycle or a removal would act on. */
+    get selectedEntry(): number | undefined;
+    move(delta: number): void;
+    render(width: number, height: number, focused: boolean): string[];
+    private verdict;
+    private acrossEvents;
+}
+/** The editable rows for one document, in the order the panel draws them. */
+export declare function buildDetailRows(record: DeliveryRecord): DetailRow[];

package/dist/commands/sys/context/admin/detail-panel.js

@@ -0,0 +1,178 @@
+// The dossier: one document's editable configuration above the read-only
+// verdict that configuration produces. Every selectable row here is a field the
+// shell can write; everything below the rule is what the planner decided.
+import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { padAnsi, theme, wrapText } from '../../../../core/tui/panel.js';
+import { SURFACE_EVENTS } from '../../../../core/substrate/schema.js';
+import { EVENT_INITIALS, cellStateOf, describeSurfaceEntry, plural } from './model.js';
+const STATE_WORD = {
+    pending: 'planning…',
+    delivers: 'delivers',
+    capped: 'capped',
+    gated: 'gated out',
+    shadowed: 'shadowed',
+    silent: 'silent',
+};
+export class ContextDetailPanel {
+    row;
+    event = 'boot';
+    capOwner = null;
+    readOnly = null;
+    rows = [];
+    index = 0;
+    /** Lines scrolled past the cursor's own window, so the verdict below the last
+     *  editable row stays reachable. */
+    tail = 0;
+    setContext(row, event, capOwner, readOnly) {
+        const changed = row?.key !== this.row?.key;
+        this.row = row;
+        this.event = event;
+        this.capOwner = capOwner;
+        this.readOnly = readOnly;
+        this.rows = row === undefined ? [] : buildDetailRows(row.anchor);
+        if (changed) {
+            this.index = 0;
+            this.tail = 0;
+        }
+        this.index = Math.max(0, Math.min(this.index, this.rows.length - 1));
+    }
+    get selected() {
+        return this.rows[this.index];
+    }
+    /** The entry index a rung cycle or a removal would act on. */
+    get selectedEntry() {
+        const row = this.selected;
+        return row?.kind === 'entry' ? row.at : undefined;
+    }
+    move(delta) {
+        const next = this.index + delta;
+        if (next < 0 || next >= this.rows.length) {
+            this.tail = Math.max(0, this.tail + delta);
+            return;
+        }
+        this.index = next;
+        this.tail = 0;
+    }
+    render(width, height, focused) {
+        const row = this.row;
+        if (row === undefined) {
+            return fit([theme.fg('dim', ' Select a document.')], height);
+        }
+        const record = row.records.get(this.event) ?? row.anchor;
+        const lines = [];
+        const rowLines = new Map();
+        lines.push(truncateToWidth(`${theme.fg('accent', theme.bold(record.name))}${this.readOnly === null ? '' : theme.fg('warning', '  read-only')}`, width));
+        lines.push(truncateToWidth(theme.fg('dim', `${record.kind} · ${record.scope}${record.nodeLocal ? ' · node-local' : ''} · ${record.source.representation}`), width));
+        lines.push(truncateToWidth(theme.fg('dim', record.storePath), width));
+        if (this.readOnly !== null)
+            lines.push(...wrapText(this.readOnly, width).map((line) => theme.fg('warning', line)));
+        lines.push('');
+        const push = (at, body) => {
+            rowLines.set(at, lines.length);
+            lines.push(at === this.index && focused
+                ? theme.bg('selectedBg', padAnsi(truncateToWidth(body, width), width))
+                : at === this.index
+                    ? `${theme.fg('accent', '▌')}${truncateToWidth(body, Math.max(0, width - 1))}`
+                    : ` ${truncateToWidth(body, Math.max(0, width - 1))}`);
+        };
+        let at = 0;
+        lines.push(theme.fg('dim', ' SURFACES'));
+        const surfaces = record.doc.surfaces;
+        if (surfaces.length === 0)
+            push(at++, theme.fg('dim', 'no entries — this document only appears in its listing'));
+        else {
+            for (const entry of surfaces) {
+                const text = describeSurfaceEntry(entry);
+                push(at++, entry.on === this.event ? text : theme.fg('dim', text));
+            }
+        }
+        push(at++, theme.fg('success', '+ add a surface entry'));
+        lines.push('');
+        lines.push(theme.fg('dim', ' DOCUMENT'));
+        push(at++, field('gate', record.doc.gate === undefined ? theme.fg('dim', 'none') : JSON.stringify(record.doc.gate), width));
+        push(at++, field('unlisted', record.doc.unlisted ? 'yes' : theme.fg('dim', 'no'), width));
+        push(at++, field('slash', record.doc.slash ? 'yes' : theme.fg('dim', 'no'), width));
+        push(at++, field('routing', record.doc.whenAndWhyToRead, width));
+        push(at++, field('short form', record.doc.shortForm === '' ? theme.fg('dim', 'none') : record.doc.shortForm, width));
+        push(at++, field('body', theme.fg('dim', `${plural(bodyLines(record.doc.body), 'line', 'lines')} \u2014 opens in $EDITOR`), width));
+        push(at++, field('profile cap', this.capOwner === null
+            ? theme.fg('dim', 'no profile project governs this store — uncapped')
+            : `${this.capOwner.memory}  ${theme.fg('dim', this.capOwner.path)}`, width));
+        push(at++, field('canonical name', record.name, width));
+        lines.push('');
+        lines.push(theme.fg('border', '─'.repeat(Math.max(0, width))));
+        lines.push(theme.fg('dim', ` VERDICT · ${this.event}`));
+        lines.push(...this.verdict(record, width));
+        lines.push('');
+        lines.push(theme.fg('dim', ' ACROSS EVENTS'));
+        lines.push(...this.acrossEvents(row, width));
+        const cursorLine = rowLines.get(this.index) ?? 0;
+        const maxStart = Math.max(0, lines.length - height);
+        let start = Math.min(Math.max(0, cursorLine - Math.floor(height / 3)), maxStart);
+        if (this.tail > 0)
+            start = Math.min(maxStart, start + this.tail);
+        return fit(lines.slice(start, start + height), height);
+    }
+    verdict(record, width) {
+        const out = [];
+        const cap = record.projectMemoryCap === null ? 'uncapped' : record.projectMemoryCap;
+        out.push(truncateToWidth(`  authored ${theme.bold(record.authoredRung)} → cap ${cap} → ${theme.fg(record.finalRung === 'none' ? 'dim' : 'success', theme.bold(record.finalRung))}`, width));
+        if (!record.docGate.pass)
+            out.push(...wrapText(`  document gate fails: ${record.docGate.reason}`, width).map((line) => theme.fg('warning', line)));
+        if (record.entryGate !== null && !record.entryGate.pass) {
+            out.push(...wrapText(`  entry gate fails: ${record.entryGate.reason}`, width).map((line) => theme.fg('warning', line)));
+        }
+        if (record.matchedEntry === null && record.authoredEntries.length > 0) {
+            out.push(theme.fg('dim', `  ${plural(record.authoredEntries.length, 'entry', 'entries')} for this event, none matched`));
+        }
+        if (record.shadowedBy !== null) {
+            out.push(...wrapText(`  shadowed by the ${record.shadowedBy.scope} copy at ${record.shadowedBy.path}`, width).map((line) => theme.fg('muted', line)));
+        }
+        else if (record.winner) {
+            out.push(theme.fg('dim', '  wins this canonical name'));
+        }
+        return out;
+    }
+    acrossEvents(row, width) {
+        return SURFACE_EVENTS.map((event) => {
+            const record = row.records.get(event);
+            const state = record === undefined ? 'silent' : cellStateOf(record);
+            const rung = record === undefined ? 'none' : record.finalRung;
+            const label = padAnsi(`  ${EVENT_INITIALS[event]} ${event}`, 20);
+            const word = STATE_WORD[state] ?? state;
+            const body = `${label} ${padAnsi(word, 11)} ${rung}`;
+            return truncateToWidth(state === 'delivers' || state === 'capped' ? body : theme.fg('dim', body), width);
+        });
+    }
+}
+/** The editable rows for one document, in the order the panel draws them. */
+export function buildDetailRows(record) {
+    const entries = record.doc.surfaces.map((_entry, at) => ({ kind: 'entry', at }));
+    return [
+        ...entries,
+        { kind: 'add-entry' },
+        { kind: 'gate' },
+        { kind: 'unlisted' },
+        { kind: 'slash' },
+        { kind: 'routing' },
+        { kind: 'short-form' },
+        { kind: 'body' },
+        { kind: 'cap' },
+        { kind: 'move' },
+    ];
+}
+function bodyLines(body) {
+    const trimmed = body.replace(/\n+$/, '');
+    return trimmed === '' ? 0 : trimmed.split('\n').length;
+}
+const FIELD_WIDTH = 15;
+function field(label, value, width) {
+    const room = Math.max(1, width - FIELD_WIDTH - 2);
+    return `${padAnsi(theme.fg('dim', label), FIELD_WIDTH)} ${truncateToWidth(value, room)}`;
+}
+function fit(lines, height) {
+    const out = [...lines];
+    while (out.length < height)
+        out.push('');
+    return out.slice(0, height).map((line) => (visibleWidth(line) === 0 ? '' : line));
+}

package/dist/commands/sys/context/admin/docs-panel.d.ts

@@ -0,0 +1,45 @@
+import { type SurfaceEvent } from '../../../../core/substrate/schema.js';
+import type { DeliveryRecord } from '../../../../core/substrate/plan.js';
+import { PlanSet } from './model.js';
+/** One physical document across every event. `records` is sparse: an event
+ *  whose corpus never reaches this document has no record for it, and an event
+ *  still being planned has none yet either. */
+export interface DocRow {
+    key: string;
+    name: string;
+    /** The record for the focused event, or the first one any event carries —
+     *  every panel needs a document to describe even when the focused event's
+     *  corpus excludes it. */
+    anchor: DeliveryRecord;
+    records: Map<SurfaceEvent, DeliveryRecord>;
+    /** Present only in an event other than the focused one. */
+    offEvent: boolean;
+}
+/** The union of every planned event's corpus, ordered by the focused event's
+ *  precedence order with the documents only other events see appended. */
+export declare function buildRows(plans: PlanSet, event: SurfaceEvent): DocRow[];
+export declare function rowDelivers(row: DocRow): boolean;
+export declare class ContextDocsPanel {
+    private readonly onChange;
+    private rows;
+    private index;
+    private filter;
+    private filtering;
+    /** Off by default: the surface is legible only when the silent documents are
+     *  visible beside the delivering ones. */
+    private deliveringOnly;
+    constructor(onChange: () => void);
+    get selected(): DocRow | undefined;
+    get ownsKeyboard(): boolean;
+    get filteringDelivering(): boolean;
+    setRows(rows: DocRow[], selectedKey?: string): void;
+    move(delta: number): void;
+    toggleDeliveringOnly(): void;
+    /** True only when a live filter consumed the input. */
+    handleInput(data: string): boolean;
+    private visible;
+    render(width: number, height: number, focused: boolean, plans: PlanSet): string[];
+    /** Pad rather than trim: this column sets the length of the divider drawn
+     *  beside it. */
+    private fit;
+}

package/dist/commands/sys/context/admin/docs-panel.js

@@ -0,0 +1,186 @@
+// The middle column: every document the snapshot can see, each carrying its own
+// six-event matrix. One row is one physical document, so two stores answering
+// to the same canonical name stay two rows and the shadowed one is visible.
+import { matchesKey, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { padAnsi, theme, visibleRange } from '../../../../core/tui/panel.js';
+import { SURFACE_EVENTS } from '../../../../core/substrate/schema.js';
+import { EVENT_INITIALS, cellGlyph, cellStateOf, plural } from './model.js';
+/** The union of every planned event's corpus, ordered by the focused event's
+ *  precedence order with the documents only other events see appended. */
+export function buildRows(plans, event) {
+    const rows = new Map();
+    const order = [];
+    const absorb = (planEvent) => {
+        const plan = plans.peek(planEvent);
+        if (plan === undefined)
+            return;
+        for (const record of plan.docs) {
+            const key = record.storePath;
+            const held = rows.get(key);
+            if (held === undefined) {
+                rows.set(key, {
+                    key,
+                    name: record.name,
+                    anchor: record,
+                    records: new Map([[planEvent, record]]),
+                    offEvent: planEvent !== event,
+                });
+                order.push(key);
+                continue;
+            }
+            held.records.set(planEvent, record);
+            if (planEvent === event) {
+                held.anchor = record;
+                held.offEvent = false;
+            }
+        }
+    };
+    absorb(event);
+    for (const other of SURFACE_EVENTS)
+        if (other !== event)
+            absorb(other);
+    return order.map((key) => rows.get(key));
+}
+export function rowDelivers(row) {
+    for (const record of row.records.values())
+        if (record.finalRung !== 'none')
+            return true;
+    return false;
+}
+/** Cells and their width, so the shell's legend and the list agree. */
+const CELL_COUNT = SURFACE_EVENTS.length;
+const MATRIX_WIDTH = CELL_COUNT * 2 - 1;
+export class ContextDocsPanel {
+    onChange;
+    rows = [];
+    index = 0;
+    filter = '';
+    filtering = false;
+    /** Off by default: the surface is legible only when the silent documents are
+     *  visible beside the delivering ones. */
+    deliveringOnly = false;
+    constructor(onChange) {
+        this.onChange = onChange;
+    }
+    get selected() {
+        const rows = this.visible();
+        this.index = Math.max(0, Math.min(this.index, rows.length - 1));
+        return rows[this.index];
+    }
+    get ownsKeyboard() {
+        return this.filtering;
+    }
+    get filteringDelivering() {
+        return this.deliveringOnly;
+    }
+    setRows(rows, selectedKey) {
+        this.rows = rows;
+        const visible = this.visible();
+        const found = selectedKey === undefined ? -1 : visible.findIndex((row) => row.key === selectedKey);
+        this.index = found >= 0 ? found : Math.min(this.index, Math.max(0, visible.length - 1));
+    }
+    move(delta) {
+        const rows = this.visible();
+        if (rows.length === 0)
+            return;
+        this.index = Math.max(0, Math.min(rows.length - 1, this.index + delta));
+        this.onChange();
+    }
+    toggleDeliveringOnly() {
+        this.deliveringOnly = !this.deliveringOnly;
+        const held = this.selected?.key;
+        this.index = 0;
+        if (held !== undefined) {
+            const at = this.visible().findIndex((row) => row.key === held);
+            if (at >= 0)
+                this.index = at;
+        }
+        this.onChange();
+    }
+    /** True only when a live filter consumed the input. */
+    handleInput(data) {
+        if (this.filtering) {
+            if (matchesKey(data, 'escape')) {
+                this.filter = '';
+                this.filtering = false;
+            }
+            else if (matchesKey(data, 'enter')) {
+                this.filtering = false;
+            }
+            else if (matchesKey(data, 'backspace')) {
+                this.filter = this.filter.slice(0, -1);
+                this.index = 0;
+            }
+            else if (data.length === 1 && data.charCodeAt(0) >= 32) {
+                this.filter += data;
+                this.index = 0;
+            }
+            this.onChange();
+            return true;
+        }
+        if (data === '/' || matchesKey(data, '/')) {
+            this.filtering = true;
+            this.onChange();
+            return true;
+        }
+        if (matchesKey(data, 'escape') && this.filter !== '') {
+            this.filter = '';
+            this.index = 0;
+            this.onChange();
+            return true;
+        }
+        return false;
+    }
+    visible() {
+        const needle = this.filter.trim().toLowerCase();
+        return this.rows.filter((row) => {
+            if (this.deliveringOnly && !rowDelivers(row))
+                return false;
+            if (needle === '')
+                return true;
+            return `${row.name}\n${row.anchor.scope}\n${row.anchor.storePath}`.toLowerCase().includes(needle);
+        });
+    }
+    render(width, height, focused, plans) {
+        const rows = this.visible();
+        const out = [];
+        const heading = this.filtering
+            ? `/${this.filter}`
+            : this.deliveringOnly
+                ? 'DELIVERING'
+                : 'DOCUMENTS';
+        const count = this.filter === '' ? plural(rows.length, 'doc', 'docs') : plural(rows.length, 'match', 'matches');
+        const matrixHead = SURFACE_EVENTS.map((event) => EVENT_INITIALS[event]).join(' ');
+        const nameRoom = Math.max(1, width - MATRIX_WIDTH - 2);
+        out.push(truncateToWidth(` ${padAnsi(`${theme.fg('accent', theme.bold(heading))} ${theme.fg('dim', count)}`, nameRoom - 1)} ${theme.fg('dim', matrixHead)}`, width));
+        if (rows.length === 0) {
+            out.push('', theme.fg('dim', this.filter === '' ? ' No documents in this snapshot\u2019s corpus.' : ' Nothing matches that filter.'));
+            return this.fit(out, height);
+        }
+        const capacity = Math.max(1, height - out.length);
+        const range = visibleRange(rows.length, this.index, capacity);
+        for (let at = range.start; at < range.end; at += 1) {
+            const row = rows[at];
+            const matrix = SURFACE_EVENTS.map((event) => {
+                const state = plans.peek(event) === undefined ? 'pending' : cellStateOf(row.records.get(event));
+                return cellGlyph(row.records.get(event), state);
+            }).join(' ');
+            const scope = theme.fg('dim', ` ${row.anchor.scope}`);
+            const label = truncateToWidth(`${row.name}${scope}`, nameRoom - 1);
+            const body = ` ${padAnsi(label, nameRoom - 1)} ${matrix}`;
+            out.push(at === this.index && focused
+                ? theme.bg('selectedBg', padAnsi(body, width))
+                : at === this.index
+                    ? `${theme.fg('accent', '▌')}${truncateToWidth(body.slice(1), Math.max(0, width - 1))}`
+                    : body);
+        }
+        return this.fit(out, height);
+    }
+    /** Pad rather than trim: this column sets the length of the divider drawn
+     *  beside it. */
+    fit(lines, height) {
+        while (lines.length < height)
+            lines.push('');
+        return lines.slice(0, height).map((line) => (visibleWidth(line) === 0 ? '' : line));
+    }
+}

package/dist/commands/sys/context/admin/model.d.ts

@@ -0,0 +1,75 @@
+import { type DeliveryPlan, type DeliveryRecord } from '../../../../core/substrate/plan.js';
+import { type Rung, type SurfaceEntry, type SurfaceEvent } from '../../../../core/substrate/schema.js';
+import { type NodeConfigSubject } from '../../../../core/substrate/subject-fields.js';
+import { type MemoryTarget } from '../../../../core/memory-resolver.js';
+/** The state an agent-engineer dials. Every axis feeds either the gate subject
+ *  or the store/cap resolution, and changing one re-plans every event. */
+export interface Snapshot {
+    kind: string;
+    mode: 'base' | 'orchestrator';
+    lifecycle: 'terminal' | 'resident';
+    hasManager: boolean;
+    profileId: string | null;
+    cwd: string;
+    nodeId: string | null;
+    depth: number;
+    event: SurfaceEvent;
+    /** `read` payload — the file that was read. */
+    file: string;
+    /** `memory-read` payload — the canonical name the read resolved to. */
+    docName: string;
+    /** `command` / `pre-command` payload. */
+    command: string;
+}
+export declare function subjectOf(snapshot: Snapshot): NodeConfigSubject;
+export declare function targetOf(snapshot: Snapshot): MemoryTarget;
+/** Which payload axis an event reads, so the rail offers exactly the one field
+ *  that can make the current event match anything. */
+export declare function payloadAxisFor(event: SurfaceEvent): 'file' | 'docName' | 'command' | null;
+/** Every plan for one snapshot, computed on demand.
+ *
+ *  Each event's corpus is its own — workspace-open sees project stores only,
+ *  boot orders node-local documents last, read pulls in the stores enclosing
+ *  the read file — so a shared corpus would report a delivery the runtime would
+ *  never make. The planner therefore loads per event, and this cache keeps the
+ *  page responsive by resolving the focused event first and warming the rest
+ *  one macrotask at a time. */
+export declare class PlanSet {
+    private snapshot;
+    private readonly plans;
+    private warming;
+    constructor(snapshot: Snapshot);
+    setSnapshot(snapshot: Snapshot): void;
+    /** Drop every plan — after a snapshot change, or after a mutation rewrote a
+     *  document the corpus was read from. */
+    invalidate(): void;
+    dispose(): void;
+    /** The plan for one event, computing it now. */
+    plan(event: SurfaceEvent): DeliveryPlan;
+    /** The plan for one event only if it is already computed — what the matrix
+     *  reads, so an uncomputed column draws as pending instead of stalling the
+     *  frame on five extra corpus loads. */
+    peek(event: SurfaceEvent): DeliveryPlan | undefined;
+    /** Compute one pending event per macrotask, calling back after each so the
+     *  matrix fills in column by column. */
+    warm(onProgress: () => void): void;
+    private payload;
+}
+/** How one document reads in one event's cell. */
+export type CellState = 'pending' | 'delivers' | 'capped' | 'gated' | 'shadowed' | 'silent';
+export declare function cellStateOf(record: DeliveryRecord | undefined): CellState;
+/** One matrix cell: the delivered rung as a filled bar, or the mark that says
+ *  why nothing is delivered. Colour separates a clean delivery from one the
+ *  profile cap trimmed, so a capped `content` never reads as an authored one. */
+export declare function cellGlyph(record: DeliveryRecord | undefined, state: CellState): string;
+/** The one-letter column heads over the matrix, in `SURFACE_EVENTS` order. */
+export declare const EVENT_INITIALS: Record<SurfaceEvent, string>;
+export declare function nextRung(rung: Rung, delta: number): Rung;
+/** A parsed entry back in the shape `memory edit --surface` accepts. The parsed
+ *  form always carries `match` as a list and spells its frontmatter key
+ *  `matchFrontmatter`; `coerceSurface` wants a bare string for a single glob
+ *  and the hyphenated key, and rejects anything else. */
+export declare function surfaceEntryToFlag(entry: SurfaceEntry): string;
+/** One authored entry as a single readable row. */
+export declare function describeSurfaceEntry(entry: SurfaceEntry): string;
+export declare function plural(count: number, one: string, many: string): string;