@north-light/crouter 0.3.243 → 0.3.244

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

@@ -1,6 +1,8 @@
-import { type Rung, type SurfaceEvent } from '../../../../core/substrate/schema.js';
+import type { SurfaceEvent } from '../../../../core/substrate/schema.js';
 import type { DeliveryRecord } from '../../../../core/substrate/plan.js';
+import { type CapOwner } from './read-view.js';
 import type { DocRow } from './docs-panel.js';
+export type { CapOwner } from './read-view.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. */
@@ -26,10 +28,6 @@ export type DetailRow = {
 } | {
     kind: 'move';
 };
-export interface CapOwner {
-    path: string;
-    memory: Rung;
-}
 export declare class ContextDetailPanel {
     private row;
     private event;
@@ -37,20 +35,45 @@ export declare class ContextDetailPanel {
     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;
+    private face;
+    private open;
+    private scroll;
+    /** Last render's geometry, so a half-pane jump and the end-of-content clamp
+     *  measure against real content rather than a counter nobody can see. */
+    private lastLines;
+    private lastHeight;
     setContext(row: DocRow | undefined, event: SurfaceEvent, capOwner: CapOwner | null, readOnly: string | null): void;
+    /** True while the field list owns the pane, so the shell routes the write
+     *  letters and teaches them in the footer. */
+    get editing(): boolean;
+    get bodyOpen(): boolean;
     get selected(): DetailRow | undefined;
     /** The entry index a rung cycle or a removal would act on. */
     get selectedEntry(): number | undefined;
+    /** `j`/`k`: a line of the read face, a field of the edit face. */
     move(delta: number): void;
+    /** `ctrl-d`/`ctrl-u`: half a pane, so a long body is crossed in jumps a
+     *  reader can still follow. */
+    page(direction: 1 | -1): void;
+    /** `g`/`G`. */
+    jump(to: 'top' | 'bottom'): void;
+    /** `enter`: the document's own text, in place. False when there is no body,
+     *  so the shell leaves the key alone. */
+    openBody(): boolean;
+    /** `e`: the field list. */
+    edit(): void;
+    /** `esc`/`h`: leave the edit face, else collapse the body. False means the
+     *  read face is already at rest and the shell should leave the dossier. */
+    back(): boolean;
+    private scrollBy;
+    private maxScroll;
+    private record;
+    private context;
     render(width: number, height: number, focused: boolean): string[];
-    private verdict;
-    /** All three rungs, not just the current one, so "what would demoting this
-     *  save" is read rather than computed. */
-    private costs;
-    private acrossEvents;
+    /** Today's field list, under the identity and delivery it is being edited
+     *  against. A row's clarifying tail renders only while that row is focused:
+     *  unfocused, twelve explanations are twelve lines of noise. */
+    private editLines;
 }
 /** 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

@@ -1,19 +1,14 @@
-// The dossier: one document's editable configuration above the read-only
-// verdict that configuration produces, and below that the document's own
-// opening lines. Every selectable row here is a field the shell can write;
-// everything below the rule is what the planner decided.
+// The dossier: one memory document, read first.
+//
+// Two faces over one pane. The read face is the resting state — who this
+// document is, when an agent reads it, what it says, and whether it loads on
+// this event — and `enter` opens its body in place. The edit face is the field
+// list every write still starts from, one `e` away. The panel owns which face
+// is showing and how far it is scrolled; it owns no text layout.
 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, formatCost, plural, rungCostsOf } from './model.js';
-const STATE_WORD = {
-    pending: 'planning…',
-    delivers: 'delivers',
-    capped: 'capped',
-    gated: 'gated out',
-    shadowed: 'shadowed',
-    silent: 'silent',
-};
+import { describeSurfaceEntry, plural } from './model.js';
+import { bodyLineCount, renderDossierDelivery, renderDossierHeader, renderDossierRead, } from './read-view.js';
 export class ContextDetailPanel {
     row;
     event = 'boot';
@@ -21,9 +16,13 @@ export class ContextDetailPanel {
     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;
+    face = 'read';
+    open = false;
+    scroll = 0;
+    /** Last render's geometry, so a half-pane jump and the end-of-content clamp
+     *  measure against real content rather than a counter nobody can see. */
+    lastLines = 1;
+    lastHeight = 1;
     setContext(row, event, capOwner, readOnly) {
         const changed = row?.key !== this.row?.key;
         this.row = row;
@@ -33,59 +32,160 @@ export class ContextDetailPanel {
         this.rows = row === undefined ? [] : buildDetailRows(row.anchor);
         if (changed) {
             this.index = 0;
-            this.tail = 0;
+            this.scroll = 0;
+            this.open = false;
+            this.face = 'read';
         }
         this.index = Math.max(0, Math.min(this.index, this.rows.length - 1));
     }
+    /** True while the field list owns the pane, so the shell routes the write
+     *  letters and teaches them in the footer. */
+    get editing() {
+        return this.face === 'edit';
+    }
+    get bodyOpen() {
+        return this.open;
+    }
     get selected() {
-        return this.rows[this.index];
+        return this.face === 'edit' ? this.rows[this.index] : undefined;
     }
     /** 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;
     }
+    // navigation
+    /** `j`/`k`: a line of the read face, a field of the edit face. */
     move(delta) {
-        const next = this.index + delta;
-        if (next < 0 || next >= this.rows.length) {
-            this.tail = Math.max(0, this.tail + delta);
+        if (this.face === 'edit') {
+            this.index = Math.max(0, Math.min(this.rows.length - 1, this.index + delta));
             return;
         }
-        this.index = next;
-        this.tail = 0;
+        this.scrollBy(delta);
     }
-    render(width, height, focused) {
+    /** `ctrl-d`/`ctrl-u`: half a pane, so a long body is crossed in jumps a
+     *  reader can still follow. */
+    page(direction) {
+        if (this.face === 'edit')
+            return;
+        this.scrollBy(direction * Math.max(1, Math.floor(this.lastHeight / 2)));
+    }
+    /** `g`/`G`. */
+    jump(to) {
+        if (this.face === 'edit')
+            return;
+        this.scroll = to === 'top' ? 0 : this.maxScroll();
+    }
+    /** `enter`: the document's own text, in place. False when there is no body,
+     *  so the shell leaves the key alone. */
+    openBody() {
+        if (this.face === 'edit' || this.row === undefined)
+            return false;
+        if (bodyLineCount(this.record().doc.body) === 0)
+            return false;
+        this.open = true;
+        this.scroll = 0;
+        return true;
+    }
+    /** `e`: the field list. */
+    edit() {
+        if (this.row === undefined)
+            return;
+        this.face = 'edit';
+        this.scroll = 0;
+    }
+    /** `esc`/`h`: leave the edit face, else collapse the body. False means the
+     *  read face is already at rest and the shell should leave the dossier. */
+    back() {
+        if (this.face === 'edit') {
+            this.face = 'read';
+            this.scroll = 0;
+            return true;
+        }
+        if (!this.open)
+            return false;
+        this.open = false;
+        this.scroll = 0;
+        return true;
+    }
+    scrollBy(delta) {
+        this.scroll = Math.max(0, Math.min(this.scroll + delta, this.maxScroll()));
+    }
+    maxScroll() {
+        return Math.max(0, this.lastLines - this.lastHeight);
+    }
+    record() {
         const row = this.row;
-        if (row === undefined) {
+        return row.records.get(this.event) ?? row.anchor;
+    }
+    context() {
+        return {
+            event: this.event,
+            records: this.row?.records ?? new Map(),
+            capOwner: this.capOwner,
+            readOnly: this.readOnly !== null,
+        };
+    }
+    // rendering
+    render(width, height, focused) {
+        if (this.row === undefined) {
+            this.lastLines = 1;
+            this.lastHeight = height;
             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))}`);
+        const record = this.record();
+        const built = this.face === 'read'
+            ? { lines: renderDossierRead(record, this.context(), width, this.open), cursor: undefined }
+            : this.editLines(record, width, focused);
+        const lines = built.lines;
+        // The badge is the pane's last row, so it costs a line of content only
+        // while there is content it cannot show anyway.
+        const overflows = lines.length > height;
+        const viewport = Math.max(1, overflows ? height - 1 : height);
+        this.lastLines = lines.length;
+        this.lastHeight = viewport;
+        let start;
+        if (built.cursor === undefined) {
+            this.scroll = Math.max(0, Math.min(this.scroll, Math.max(0, lines.length - viewport)));
+            start = this.scroll;
+        }
+        else {
+            start = Math.min(Math.max(0, built.cursor - Math.floor(viewport / 3)), Math.max(0, lines.length - viewport));
+        }
+        const window = fit(lines.slice(start, start + viewport), viewport);
+        if (!overflows)
+            return window;
+        window.push(badge(start + 1, Math.min(lines.length, start + viewport), lines.length, width));
+        return window;
+    }
+    /** Today's field list, under the identity and delivery it is being edited
+     *  against. A row's clarifying tail renders only while that row is focused:
+     *  unfocused, twelve explanations are twelve lines of noise. */
+    editLines(record, width, focused) {
+        const context = this.context();
+        const lines = [...renderDossierHeader(record, context, width), ...renderDossierDelivery(record, context, width), ''];
+        let cursor = 0;
+        const push = (at, body, tail) => {
+            const own = [body, ...(at === this.index && tail !== undefined ? tailLines(tail, width) : [])];
+            if (at === this.index)
+                cursor = lines.length;
+            for (const line of own) {
+                lines.push(at === this.index && focused
+                    ? theme.bg('selectedBg', padAnsi(truncateToWidth(line, width), width))
+                    : at === this.index
+                        ? `${theme.fg('accent', '\u258c')}${truncateToWidth(line, Math.max(0, width - 1))}`
+                        : ` ${truncateToWidth(line, 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));
-            }
+        if (surfaces.length === 0) {
+            lines.push(theme.fg('dim', ' no entries — this document only appears in its listing'));
+        }
+        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('');
@@ -95,71 +195,13 @@ export class ContextDetailPanel {
         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('body', theme.fg('dim', plural(bodyLineCount(record.doc.body), 'line', 'lines')), width), 'opens in $EDITOR');
+        push(at++, field('profile cap', this.capOwner === null ? theme.fg('dim', 'uncapped') : `${this.capOwner.memory}  ${theme.fg('dim', this.capOwner.path)}`, width), this.capOwner === null
+            ? 'no profile project governs this store'
+            : 'the highest rung any document from this store can deliver at');
         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', ' COST IF DELIVERED · approximate'));
-        lines.push(...this.costs(record, width));
-        lines.push('');
-        lines.push(theme.fg('dim', ' ACROSS EVENTS'));
-        lines.push(...this.acrossEvents(row, width));
-        lines.push('');
-        lines.push(theme.fg('dim', ' BODY'));
-        lines.push(...bodyPreview(record.doc.body, width, height));
-        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;
-    }
-    /** All three rungs, not just the current one, so "what would demoting this
-     *  save" is read rather than computed. */
-    costs(record, width) {
-        const costs = rungCostsOf(record);
-        const cells = ['content', 'preview', 'name'].map((rung) => {
-            const text = `${padAnsi(rung, 8)}${padAnsi(formatCost(costs[rung]) || '~0', 8)}`;
-            return rung === record.finalRung ? theme.fg('success', text) : theme.fg('dim', text);
-        });
-        return [truncateToWidth(`  ${cells.join(' ')}`, width)];
-    }
-    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);
-        });
+        lines.push(` ${field('store path', theme.fg('dim', record.storePath), Math.max(0, width - 1))}`);
+        return { lines, cursor };
     }
 }
 /** The editable rows for one document, in the order the panel draws them. */
@@ -178,27 +220,22 @@ export function buildDetailRows(record) {
         { kind: 'move' },
     ];
 }
-function bodyLines(body) {
-    const trimmed = body.replace(/\n+$/, '');
-    return trimmed === '' ? 0 : trimmed.split('\n').length;
-}
-/** The document's opening lines, filling the rows the dossier would otherwise
- *  leave blank. Bounded by the pane height: past that the reader is scrolling,
- *  and the body opens in $EDITOR. */
-function bodyPreview(body, width, height) {
-    const trimmed = body.trim();
-    if (trimmed === '')
-        return [theme.fg('dim', '  (empty)')];
-    return trimmed
-        .split('\n')
-        .slice(0, Math.max(1, height))
-        .map((line) => theme.fg('dim', truncateToWidth(`  ${line}`, width)));
-}
 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)}`;
 }
+/** A focused row's explanation, hanging under its value rather than its label. */
+function tailLines(text, width) {
+    const room = Math.max(1, width - FIELD_WIDTH - 2);
+    return wrapText(`\u2014 ${text}`, room).map((line) => `${' '.repeat(FIELD_WIDTH + 1)}${theme.fg('dim', line)}`);
+}
+/** Where the visible window sits in the whole document, drawn only while there
+ *  is something outside it. */
+function badge(from, to, total, width) {
+    const text = `${from}\u2013${to} / ${total}`;
+    return theme.fg('dim', `${' '.repeat(Math.max(0, width - text.length))}${text}`);
+}
 function fit(lines, height) {
     const out = [...lines];
     while (out.length < height)

package/dist/commands/sys/context/admin/read-view.d.ts

@@ -0,0 +1,27 @@
+import { type Rung, type SurfaceEvent } from '../../../../core/substrate/schema.js';
+import type { DeliveryRecord } from '../../../../core/substrate/plan.js';
+/** The profile project entry whose `memory` rung ceilings this document's
+ *  store, or null when no project governs it. */
+export interface CapOwner {
+    path: string;
+    memory: Rung;
+}
+/** What the read face needs beyond the record: the event it is judged against,
+ *  the sibling events' records, and the two facts the shell resolves. */
+export interface DossierContext {
+    event: SurfaceEvent;
+    records: Map<SurfaceEvent, DeliveryRecord>;
+    capOwner: CapOwner | null;
+    readOnly: boolean;
+}
+/** The resting card, and — when `bodyOpen` — the document's own text beneath
+ *  it in place of the affordance line that names it. */
+export declare function renderDossierRead(record: DeliveryRecord, context: DossierContext, width: number, bodyOpen: boolean): string[];
+/** Identity and routing — what the edit face keeps overhead of its field list,
+ *  because they are the context a field is being edited against. */
+export declare function renderDossierHeader(record: DeliveryRecord, context: DossierContext, width: number): string[];
+/** Does it load here, what does it cost, and — only when there is one — what
+ *  interfered. The three questions the old verdict, cost table and event grid
+ *  each answered a piece of. */
+export declare function renderDossierDelivery(record: DeliveryRecord, context: DossierContext, width: number): string[];
+export declare function bodyLineCount(body: string): number;

package/dist/commands/sys/context/admin/read-view.js

@@ -0,0 +1,152 @@
+// The dossier's read face: one memory document as the thing a person reads to
+// decide whether it should load into this context.
+//
+// Pure rendering. It returns styled lines already wrapped to `width` and never
+// truncates a value — the panel scrolls, so scrolling is the only thing that
+// hides text, and "the routing line never ellipsizes" is structural rather than
+// a rule someone has to remember.
+//
+// One rule decides what appears: a line renders only when it changes what the
+// reader would conclude. A gate that is unset, a cap that lowers nothing, an
+// event that delivers nothing — all absent.
+import { getMarkdownTheme } from '@earendil-works/pi-coding-agent';
+import { Markdown, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { theme, wrapText } from '../../../../core/tui/panel.js';
+import { SURFACE_EVENTS, rungRank } from '../../../../core/substrate/schema.js';
+import { formatCost, plural, rungCostsOf } from './model.js';
+/** Read-only, at rest: no word and no sentence. The refusal itself is a notice
+ *  fired at the moment a write is attempted. */
+const READ_ONLY_GLYPH = '\u2298';
+/** Every column but the left margin, which every line of the card carries. */
+const INDENT = ' ';
+/** The resting card, and — when `bodyOpen` — the document's own text beneath
+ *  it in place of the affordance line that names it. */
+export function renderDossierRead(record, context, width, bodyOpen) {
+    const inner = Math.max(1, width - INDENT.length);
+    const out = renderDossierHeader(record, context, width);
+    if (record.doc.shortForm.trim() !== '') {
+        out.push('');
+        out.push(...indent(wrapped(record.doc.shortForm, inner)));
+    }
+    out.push(...renderDossierDelivery(record, context, width));
+    const lines = bodyLineCount(record.doc.body);
+    if (bodyOpen) {
+        out.push('');
+        out.push(...indent(new Markdown(record.doc.body, 0, 0, getMarkdownTheme()).render(inner)));
+    }
+    else if (lines === 0) {
+        out.push('', ...dim('no body — this document is its routing line', width));
+    }
+    else {
+        out.push('', ...dim(`enter  read the body \u2014 ${plural(lines, 'line', 'lines')}`, width));
+    }
+    return out;
+}
+/** A dim line of the card, kept exactly as written while the row can hold it
+ *  and wrapped when it cannot — so a narrow dossier costs a second row rather
+ *  than an ellipsis. */
+function dim(text, width) {
+    const inner = Math.max(1, width - INDENT.length);
+    return visibleWidth(text) <= inner
+        ? [`${INDENT}${theme.fg('dim', text)}`]
+        : indent(wrapped(text, inner)).map((line) => theme.fg('dim', line));
+}
+/** Identity and routing — what the edit face keeps overhead of its field list,
+ *  because they are the context a field is being edited against. */
+export function renderDossierHeader(record, context, width) {
+    const inner = Math.max(1, width - INDENT.length);
+    const out = identityLines(record, context, inner);
+    out.push('', theme.fg('dim', `${INDENT}READ WHEN`));
+    const routing = record.doc.whenAndWhyToRead.trim();
+    out.push(...(routing === ''
+        ? [theme.fg('dim', `${INDENT}Not declared.`)]
+        : indent(wrapped(routing, inner))));
+    return out;
+}
+/** The name, with the metadata cluster pushed to the far right of the same row
+ *  whenever both fit. A name too long to share the row keeps every character
+ *  and the cluster drops to its own row. */
+function identityLines(record, context, inner) {
+    const meta = `${record.kind} \u00b7 ${record.scope}${record.nodeLocal ? ' \u00b7 node-local' : ''}${context.readOnly ? ` ${READ_ONLY_GLYPH}` : ''}`;
+    const names = wrapped(record.name, inner);
+    const out = names.map((line) => `${INDENT}${theme.fg('accent', theme.bold(line))}`);
+    const last = names[names.length - 1] ?? '';
+    const gap = inner - visibleWidth(last) - visibleWidth(meta);
+    if (gap >= 2) {
+        out[out.length - 1] = `${INDENT}${theme.fg('accent', theme.bold(last))}${' '.repeat(gap)}${theme.fg('dim', meta)}`;
+        return out;
+    }
+    // The cluster takes its own row, right-aligned under the name — or its own
+    // rows, when the dossier is too narrow to hold it in one.
+    out.push(...wrapped(meta, inner).map((line) => `${INDENT}${' '.repeat(Math.max(0, inner - visibleWidth(line)))}${theme.fg('dim', line)}`));
+    return out;
+}
+/** Does it load here, what does it cost, and — only when there is one — what
+ *  interfered. The three questions the old verdict, cost table and event grid
+ *  each answered a piece of. */
+export function renderDossierDelivery(record, context, width) {
+    const inner = Math.max(1, width - INDENT.length);
+    const costs = rungCostsOf(record);
+    const delivers = record.finalRung !== 'none';
+    const ceilingLowered = rungRank(record.cappedRung) < rungRank(record.authoredRung);
+    const rung = delivers ? record.finalRung : 'nothing';
+    const cost = delivers ? ` \u00b7 ${formatCost(costs[record.finalRung]) || '~0'} of ${formatCost(costs.content) || '~0'}` : '';
+    const color = !delivers ? 'dim' : ceilingLowered ? 'warning' : 'success';
+    const asked = `${context.event} \u2192 `;
+    const answer = `${rung}${cost}`;
+    const out = [''];
+    if (visibleWidth(asked) + visibleWidth(answer) <= inner) {
+        out.push(`${INDENT}${theme.fg('dim', asked)}${theme.fg(color, rung)}${theme.fg('dim', cost)}`);
+    }
+    else {
+        // Too narrow for one row: the event names itself and its verdict wraps
+        // beneath, rather than the cost ellipsizing off the end.
+        out.push(...indent(wrapped(asked, inner)).map((line) => theme.fg('dim', line)));
+        out.push(...indent(wrapped(answer, inner)).map((line) => theme.fg(color, line)));
+    }
+    const warn = (text) => {
+        out.push(...indent(wrapped(text, inner)).map((line) => theme.fg('warning', line)));
+    };
+    if (!record.docGate.pass)
+        warn(`gate fails: ${record.docGate.reason}`);
+    if (record.entryGate !== null && !record.entryGate.pass)
+        warn(`entry gate fails: ${record.entryGate.reason}`);
+    if (record.matchedEntry === null && record.authoredEntries.length > 0) {
+        out.push(...indent(wrapped(`${plural(record.authoredEntries.length, 'entry', 'entries')} for this event, none matched`, inner)).map((line) => theme.fg('dim', line)));
+    }
+    if (ceilingLowered) {
+        warn(context.capOwner === null
+            ? `capped to ${record.cappedRung} by a profile ceiling on this store`
+            : `capped to ${record.cappedRung} by the ${context.capOwner.memory} ceiling on ${context.capOwner.path}`);
+    }
+    if (record.shadowedBy !== null) {
+        out.push(...indent(wrapped(`shadowed by the ${record.shadowedBy.scope} copy at ${record.shadowedBy.path}`, inner)).map((line) => theme.fg('muted', line)));
+    }
+    const also = SURFACE_EVENTS.filter((event) => event !== context.event)
+        .map((event) => ({ event, held: context.records.get(event) }))
+        .filter((pair) => pair.held !== undefined && pair.held.finalRung !== 'none')
+        .map((pair) => `${pair.event} \u2192 ${pair.held.finalRung}`);
+    if (also.length > 0) {
+        out.push(...indent(wrapped(`also ${also.join(' \u00b7 ')}`, inner)).map((line) => theme.fg('dim', line)));
+    }
+    return out;
+}
+export function bodyLineCount(body) {
+    const trimmed = body.replace(/\n+$/, '');
+    return trimmed === '' ? 0 : trimmed.split('\n').length;
+}
+function indent(lines) {
+    return lines.map((line) => `${INDENT}${line}`);
+}
+/** `wrapText` is the page's prose wrapper, and its word-oriented contract
+ *  deliberately leaves a filesystem path or a compact JSON predicate intact.
+ *  Values carrying such a token go through pi-tui's character-safe wrapper
+ *  instead, so an over-wide token breaks rather than becoming an ellipsis. */
+function wrapped(text, width) {
+    const clean = text.trim();
+    if (clean === '')
+        return [];
+    return clean.split(/\s+/).some((word) => visibleWidth(word) > width)
+        ? wrapTextWithAnsi(clean, width)
+        : wrapText(clean, width);
+}

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

@@ -63,6 +63,18 @@ export declare class ContextAdminShell implements Component, Focusable {
      *  modal over the rows it is selecting. */
     private handleSearch;
     private handleDetail;
+    /** The resting face: reading, and the two gestures that leave it. */
+    private handleRead;
+    /** The field list. Every write gesture is resolved before it is started, so a
+     *  read-only document refuses at the keypress rather than after a modal. */
+    private handleEdit;
+    /** The write one edit-face key starts, or undefined when the key writes
+     *  nothing. `document` marks the writes a read-only document refuses — the
+     *  profile ceiling is not one of them; it lives in the profile manifest. */
+    private writeGesture;
+    /** The refusal a read-only document owes the write just attempted, carried by
+     *  the same footer channel every other write outcome uses. */
+    private refusesWrite;
     /** What the focused dossier row does when opened — the same write its letter
      *  key starts, so a user who never learns the letters can still edit. */
     private activate;

package/dist/commands/sys/context/admin/shell.js

@@ -158,7 +158,10 @@ export class ContextAdminShell {
             this.setSnapshot(cycleAxis(this.snapshot, 'event', step));
             return;
         }
-        if (matchesKey(data, 'q') || this.matches('crtr.setup.cancel', data)) {
+        // `crtr.setup.cancel` also claims ctrl+d, so the read face's half-pane
+        // gesture has to outrank it or paging a body would close the page instead.
+        const pagesBody = this.zone === 'detail' && !this.detail.editing && matchesKey(data, 'ctrl+d');
+        if (!pagesBody && (matchesKey(data, 'q') || this.matches('crtr.setup.cancel', data))) {
             this.close();
             return;
         }
@@ -268,35 +271,101 @@ export class ContextAdminShell {
         this.tui.requestRender();
     }
     handleDetail(data) {
+        if (this.detail.editing)
+            this.handleEdit(data);
+        else
+            this.handleRead(data);
+    }
+    /** The resting face: reading, and the two gestures that leave it. */
+    handleRead(data) {
         if (this.isDown(data))
             this.detail.move(1);
         else if (this.isUp(data))
             this.detail.move(-1);
-        else if (this.isAscend(data) || matchesKey(data, 'escape'))
-            this.zone = 'docs';
-        else if (matchesKey(data, 'enter') || matchesKey(data, 'space') || this.matches('crtr.setup.toggle', data)) {
-            this.activate();
-        }
-        else if (matchesKey(data, 'b'))
-            this.editBody();
-        else if (matchesKey(data, 'x'))
-            this.removeEntry();
-        else if (matchesKey(data, 'e'))
-            this.composeEntry();
-        else if (matchesKey(data, 'g'))
-            this.editGate();
-        else if (matchesKey(data, 'u'))
-            this.flip('unlisted');
-        else if (matchesKey(data, 's'))
-            this.flip('slash');
-        else if (matchesKey(data, 'm'))
-            this.editCap();
-        else if (matchesKey(data, 'r'))
-            this.editMove();
-        else if (matchesKey(data, 'w'))
-            this.editRouting();
-        else if (matchesKey(data, 'f'))
-            this.editShortForm();
+        else if (matchesKey(data, 'ctrl+d'))
+            this.detail.page(1);
+        else if (matchesKey(data, 'ctrl+u'))
+            this.detail.page(-1);
+        else if (data === 'G' || matchesKey(data, 'shift+g'))
+            this.detail.jump('bottom');
+        else if (data === 'g' || matchesKey(data, 'g'))
+            this.detail.jump('top');
+        else if (data === 'e' || matchesKey(data, 'e'))
+            this.detail.edit();
+        else if (this.isDescend(data))
+            this.detail.openBody();
+        else if (this.isAscend(data) || matchesKey(data, 'escape')) {
+            if (!this.detail.back())
+                this.zone = 'docs';
+        }
+    }
+    /** The field list. Every write gesture is resolved before it is started, so a
+     *  read-only document refuses at the keypress rather than after a modal. */
+    handleEdit(data) {
+        if (this.isDown(data)) {
+            this.detail.move(1);
+            return;
+        }
+        if (this.isUp(data)) {
+            this.detail.move(-1);
+            return;
+        }
+        if (this.isAscend(data) || matchesKey(data, 'escape')) {
+            this.detail.back();
+            return;
+        }
+        const gesture = this.writeGesture(data);
+        if (gesture === undefined)
+            return;
+        if (gesture.document && this.refusesWrite())
+            return;
+        gesture.start();
+    }
+    /** The write one edit-face key starts, or undefined when the key writes
+     *  nothing. `document` marks the writes a read-only document refuses — the
+     *  profile ceiling is not one of them; it lives in the profile manifest. */
+    writeGesture(data) {
+        const doc = (start) => ({ start, document: true });
+        if (matchesKey(data, 'enter') || matchesKey(data, 'space') || this.matches('crtr.setup.toggle', data)) {
+            const row = this.detail.selected;
+            if (row === undefined)
+                return undefined;
+            return row.kind === 'cap' ? { start: () => this.editCap(), document: false } : doc(() => this.activate());
+        }
+        if (matchesKey(data, 'm'))
+            return { start: () => this.editCap(), document: false };
+        if (matchesKey(data, 'b'))
+            return doc(() => this.editBody());
+        if (matchesKey(data, 'x'))
+            return doc(() => this.removeEntry());
+        if (matchesKey(data, 'e'))
+            return doc(() => this.composeEntry());
+        if (matchesKey(data, 'g'))
+            return doc(() => this.editGate());
+        if (matchesKey(data, 'u'))
+            return doc(() => this.flip('unlisted'));
+        if (matchesKey(data, 's'))
+            return doc(() => this.flip('slash'));
+        if (matchesKey(data, 'r'))
+            return doc(() => this.editMove());
+        if (matchesKey(data, 'w'))
+            return doc(() => this.editRouting());
+        if (matchesKey(data, 'f'))
+            return doc(() => this.editShortForm());
+        return undefined;
+    }
+    /** The refusal a read-only document owes the write just attempted, carried by
+     *  the same footer channel every other write outcome uses. */
+    refusesWrite() {
+        const record = this.record;
+        if (record === undefined)
+            return false;
+        const refusal = readOnlyReason(record, this.snapshot.profileId);
+        if (refusal === null)
+            return false;
+        this.notice = { text: refusal, ok: false };
+        this.tui.requestRender();
+        return true;
     }
     /** What the focused dossier row does when opened — the same write its letter
      *  key starts, so a user who never learns the letters can still edit. */
@@ -472,13 +541,6 @@ export class ContextAdminShell {
         const record = this.record;
         if (record === undefined)
             return;
-        // Checked before the terminal leaves for $EDITOR, so a read-only record
-        // refuses in place rather than after a whole editing session.
-        const refusal = readOnlyReason(record, this.snapshot.profileId);
-        if (refusal !== null) {
-            this.notice = { text: refusal, ok: false };
-            return;
-        }
         let before;
         try {
             before = readBody(record);
@@ -651,7 +713,11 @@ export class ContextAdminShell {
             ? `${move} row · space change · enter documents`
             : this.zone === 'docs'
                 ? `${move} row · ${this.docsGesture()} · / search`
-                : `${move} field · enter edit · e add · x remove · g gate · b body · u unlisted · s slash · m cap · r rename`;
+                : this.detail.editing
+                    ? `${move} field · enter edit · e add · x remove · g gate · b body · u unlisted · s slash · m cap · r rename · esc read`
+                    : this.detail.bodyOpen
+                        ? `${move} scroll · ctrl-d/u page · g/G ends · esc collapse`
+                        : `${move} scroll · enter body · e edit · esc list`;
         const right = `${this.label('crtr.setup.tab-next', 'tab')} event · ${this.label('crtr.setup.cancel', 'q')} close`;
         const gap = width - visibleWidth(left) - visibleWidth(right);
         return gap >= 2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.243",
+  "version": "0.3.244",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.243",
+  "version": "0.3.244",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.243",
+      "version": "0.3.244",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {