@north-light/crouter 0.3.240 → 0.3.242

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

@@ -5,7 +5,7 @@ import { resolve as resolvePath } from 'node:path';
 import { theme } from '../../../../core/tui/panel.js';
 import { realpathOrSelf } from '../../../../core/fs-utils.js';
 import { planDelivery, } from '../../../../core/substrate/plan.js';
-import { RUNGS, SURFACE_EVENTS, rungRank, } from '../../../../core/substrate/schema.js';
+import { RUNGS, SURFACE_EVENTS, previewLine, rungRank, } from '../../../../core/substrate/schema.js';
 import { scopeForCwd, profileNameFor } from '../../../../core/substrate/subject-fields.js';
 import { resolveMemoryDocForTarget } from '../../../../core/memory-resolver.js';
 export function subjectOf(snapshot) {
@@ -207,3 +207,30 @@ export function describeSurfaceEntry(entry) {
 export function plural(count, one, many) {
     return `${count} ${count === 1 ? one : many}`;
 }
+export function rungCostsOf(record) {
+    const entry = record.name.length;
+    const routing = previewLine(record.doc).length;
+    return {
+        none: 0,
+        name: tokens(entry),
+        preview: tokens(entry + routing),
+        content: tokens(record.doc.body.length),
+    };
+}
+/** What this document actually spends in the event the record belongs to. */
+export function deliveredCost(record) {
+    return record === undefined ? 0 : rungCostsOf(record)[record.finalRung];
+}
+function tokens(characters) {
+    return Math.ceil(characters / 4);
+}
+/** Approximate tokens in at most six columns, always marked as an estimate. */
+export function formatCost(count) {
+    if (count <= 0)
+        return '';
+    if (count < 1000)
+        return `~${count}`;
+    if (count < 10_000)
+        return `~${(count / 1000).toFixed(1)}k`;
+    return `~${Math.round(count / 1000)}k`;
+}

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

@@ -0,0 +1,46 @@
+import { type Snapshot } from './model.js';
+import type { Filters } from './list-view.js';
+export type AxisId = 'event' | 'payload' | 'kind' | 'mode' | 'lifecycle' | 'manager' | 'depth' | 'profile' | 'cwd';
+export interface Axis {
+    id: AxisId;
+    label: string;
+    value: string;
+    /** Free-text axes open a field; the rest cycle in place. */
+    typed: boolean;
+}
+export type FacetId = 'rung' | 'origin' | 'kind' | 'state' | 'query';
+export interface Facet {
+    id: FacetId;
+    label: string;
+    value: string;
+    /** The query is typed; every other facet cycles through a closed set. */
+    typed: boolean;
+}
+/** The FILTERS rows for one filter value. `doc kind` is spelled out because the
+ *  snapshot above it dials the NODE's kind. */
+export declare function facetsOf(filters: Filters): Facet[];
+export declare function cycleFacet(filters: Filters, id: FacetId, delta: number): Filters;
+/** 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 declare function axesOf(snapshot: Snapshot, profileName: string): Axis[];
+/** Cycle one enum axis, returning the changed snapshot. A typed axis is never
+ *  cycled — the shell opens a field for it instead. */
+export declare function cycleAxis(snapshot: Snapshot, id: AxisId, delta: number): Snapshot;
+/** Apply a typed axis's submitted value. */
+export declare function setTypedAxis(snapshot: Snapshot, id: AxisId, value: string): Snapshot;
+/** The value a typed axis's field is seeded with. */
+export declare function typedAxisValue(snapshot: Snapshot, id: AxisId): string;
+/** Both sections as one column. `index` runs over the axes and then the facets
+ *  — the order the shell routes a cycle in — while the section headings and the
+ *  blank rows between them are drawn but never selectable. */
+export declare function renderRail(opts: {
+    axes: Axis[];
+    facets: Facet[];
+    index: number;
+    width: number;
+    height: number;
+    focused: boolean;
+    /** Documents the filters select, out of the whole corpus. */
+    matched: number;
+    total: number;
+}): string[];

package/dist/commands/sys/context/admin/{axes-panel.js → rail-panel.js}

@@ -1,11 +1,45 @@
-// 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.
+// The rail: two sections in one row grammar. SNAPSHOT holds the configuration
+// axes the page plans against — changing one re-plans every event. FILTERS holds
+// the question asked of that plan — changing one only changes what is shown.
+// An enum cycles in place; a free-text row opens a field.
 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 { padAnsi, theme } from '../../../../core/tui/panel.js';
+import { KINDS, RUNGS, SURFACE_EVENTS } from '../../../../core/substrate/schema.js';
 import { listProfiles } from '../../../../core/profiles/manifest.js';
 import { payloadAxisFor } from './model.js';
+const RUNG_FACETS = ['any', ...RUNGS.filter((rung) => rung !== 'none'), 'silent'];
+const ORIGIN_FACETS = ['any', 'project', 'user', 'profile', 'builtin', 'node'];
+const KIND_FACETS = ['any', ...KINDS];
+const STATE_FACETS = ['any', 'delivering', 'gated', 'shadowed', 'no-entry'];
+/** The FILTERS rows for one filter value. `doc kind` is spelled out because the
+ *  snapshot above it dials the NODE's kind. */
+export function facetsOf(filters) {
+    return [
+        { id: 'rung', label: 'rung', value: filters.rung, typed: false },
+        { id: 'origin', label: 'origin', value: filters.origin, typed: false },
+        { id: 'kind', label: 'doc kind', value: filters.kind, typed: false },
+        { id: 'state', label: 'state', value: filters.state, typed: false },
+        { id: 'query', label: 'search', value: filters.query === '' ? 'any' : filters.query, typed: true },
+    ];
+}
+export function cycleFacet(filters, 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 'rung':
+            return { ...filters, rung: step(RUNG_FACETS, filters.rung) };
+        case 'origin':
+            return { ...filters, origin: step(ORIGIN_FACETS, filters.origin) };
+        case 'kind':
+            return { ...filters, kind: step(KIND_FACETS, filters.kind) };
+        case 'state':
+            return { ...filters, state: step(STATE_FACETS, filters.state) };
+        case 'query':
+            return filters;
+    }
+}
 function tildify(path) {
     const home = process.env['HOME'];
     return home !== undefined && home !== '' && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
@@ -92,26 +126,35 @@ export function typedAxisValue(snapshot, id) {
     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()) {
+/** Both sections as one column. `index` runs over the axes and then the facets
+ *  — the order the shell routes a cycle in — while the section headings and the
+ *  blank rows between them are drawn but never selectable. */
+export function renderRail(opts) {
+    const { axes, facets, index, width, height, focused, matched, total } = opts;
+    const lines = [];
+    let cursorLine = 0;
+    const push = (at, label, value) => {
         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}`;
+        const padded = padAnsi(truncateToWidth(label, LABEL_WIDTH), LABEL_WIDTH);
+        const shown = truncateToWidth(value, room);
+        const body = ` ${padded} ${shown}`;
+        if (at === index)
+            cursorLine = lines.length;
         if (at === index && focused)
-            rows.push(theme.bg('selectedBg', padAnsi(body, width)));
+            lines.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)}`);
+            lines.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));
+            lines.push(padAnsi(` ${theme.fg('dim', padded)} ${shown}`, width));
+    };
+    lines.push(theme.fg('dim', ' SNAPSHOT'), '');
+    axes.forEach((axis, at) => push(at, axis.label, axis.value));
+    lines.push('', theme.fg('dim', ` FILTERS · ${matched} of ${total}`), '');
+    facets.forEach((facet, at) => push(axes.length + at, facet.label, facet.value));
+    const maxStart = Math.max(0, lines.length - height);
+    const start = Math.min(Math.max(0, cursorLine - Math.floor(height / 2)), maxStart);
+    const out = lines.slice(start, start + height);
     while (out.length < height)
         out.push('');
-    return out.slice(0, height);
+    return out;
 }

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

@@ -14,7 +14,11 @@ export declare class ContextAdminShell implements Component, Focusable {
     private snapshot;
     private plans;
     private zone;
-    private axisIndex;
+    private railIndex;
+    private filters;
+    private rows;
+    /** The search field owns the keyboard while it is open. */
+    private searching;
     private readonly docs;
     private readonly detail;
     private modal;
@@ -35,6 +39,9 @@ export declare class ContextAdminShell implements Component, Focusable {
     /** Recompute the focused event's plan, refresh the panels from it, and let
      *  the remaining events fill in behind it. */
     private rebuild;
+    /** A filter never re-plans: it is a question about the plan already computed,
+     *  which is what keeps a facet change instant on a corpus this size. */
+    private setFilters;
     private syncDetail;
     private setSnapshot;
     private matches;
@@ -47,8 +54,14 @@ export declare class ContextAdminShell implements Component, Focusable {
      *  drawn against, so it earns the page-level gesture. */
     private cyclesEvent;
     handleInput(data: string): void;
-    private handleAxes;
+    /** The rail's rows are the snapshot axes followed by the filter facets, so
+     *  one cursor and one gesture drive both sections. */
+    private handleRail;
     private handleDocs;
+    private openSearch;
+    /** Typing filters live, so the field is the list's own heading rather than a
+     *  modal over the rows it is selecting. */
+    private handleSearch;
     private handleDetail;
     /** 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. */
@@ -78,5 +91,9 @@ export declare class ContextAdminShell implements Component, Focusable {
     private renderModal;
     private footer;
     render(width: number): string[];
+    /** What the delivering documents spend on this event. An estimate, and a
+     *  floor on the rendered prompt: boot wraps these documents in its own intro
+     *  prose and catalog tree. */
+    private costMeta;
 }
 export declare function runContextAdmin(seed: Snapshot): Promise<AdminResult | undefined>;

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

@@ -1,7 +1,7 @@
-// The `crtr sys context admin` page: a snapshot rail, the document matrix, and
-// the dossier that edits one document's routing. The rail decides WHAT is being
-// planned, the matrix shows WHERE every document lands, and the dossier is the
-// only place a write starts.
+// The `crtr sys context admin` page: a rail, the document matrix, and the
+// dossier that edits one document's routing. The rail decides WHAT is being
+// planned and WHICH slice of it is shown, the matrix shows WHERE every document
+// lands, and the dossier is the only place a write starts.
 import { Input, matchesKey, truncateToWidth, visibleWidth, } from '@earendil-works/pi-tui';
 import { formatGesture, matchesPiTuiInput, } from '../../../../core/keybindings/index.js';
 import { runTuiPage } from '../../../../core/tui/page-host.js';
@@ -10,14 +10,26 @@ import { RUNGS, SURFACE_EVENTS, SURFACE_RUNGS, } from '../../../../core/substrat
 import { profileNameFor } from '../../../../core/substrate/subject-fields.js';
 import { editBufferInEditor } from '../../../../clients/inbox/review/roundtrip.js';
 import { capOwnerFor, moveDoc, readBody, readOnlyReason, toggleFlag, writeBody, writeCap, writeGate, writeRoutingLine, writeShortForm, writeSurfaces, } from './actions.js';
-import { axesOf, cycleAxis, setTypedAxis, renderAxes, typedAxisValue } from './axes-panel.js';
+import { axesOf, cycleAxis, cycleFacet, facetsOf, renderRail, setTypedAxis, typedAxisValue, } from './rail-panel.js';
 import { ContextDetailPanel } from './detail-panel.js';
 import { ContextDocsPanel, buildRows } from './docs-panel.js';
-import { PlanSet, plural } from './model.js';
+import { NO_FILTERS, costTotals } from './list-view.js';
+import { PlanSet, formatCost, plural } from './model.js';
 const RAIL_WIDTH = 26;
-const DOCS_WIDTH = 38;
 const RAIL_MIN_TOTAL_WIDTH = 86;
 const THREE_COLUMN_MIN_WIDTH = 112;
+/** Columns the two dividers between the three zones spend. */
+const DIVIDER_WIDTH = 6;
+/** Below the floor a row cannot hold a name beside the matrix; above the
+ *  ceiling extra width stops buying legibility and the dossier wants it. */
+const DOCS_MIN_WIDTH = 48;
+const DOCS_MAX_WIDTH = 100;
+const DOCS_SHARE = 0.45;
+/** The list's share of what is left after the rail and the dividers. */
+function docsWidthFor(width) {
+    const room = Math.max(1, width - RAIL_WIDTH - DIVIDER_WIDTH);
+    return Math.max(DOCS_MIN_WIDTH, Math.min(DOCS_MAX_WIDTH, Math.floor(room * DOCS_SHARE)));
+}
 export class ContextAdminShell {
     tui;
     terminalRows;
@@ -25,8 +37,12 @@ export class ContextAdminShell {
     suspendForChild;
     snapshot;
     plans;
-    zone = 'axes';
-    axisIndex = 0;
+    zone = 'rail';
+    railIndex = 0;
+    filters = NO_FILTERS;
+    rows = [];
+    /** The search field owns the keyboard while it is open. */
+    searching = false;
     docs;
     detail = new ContextDetailPanel();
     modal;
@@ -64,14 +80,23 @@ export class ContextAdminShell {
      *  the remaining events fill in behind it. */
     rebuild(selectedKey) {
         this.plans.plan(this.snapshot.event);
-        this.docs.setRows(buildRows(this.plans, this.snapshot.event), selectedKey ?? this.docs.selected?.key);
+        this.rows = buildRows(this.plans, this.snapshot.event);
+        this.docs.setRows(this.rows, this.snapshot.event, selectedKey ?? this.docs.selected?.key);
         this.syncDetail();
         this.plans.warm(() => {
-            this.docs.setRows(buildRows(this.plans, this.snapshot.event), this.docs.selected?.key);
+            this.rows = buildRows(this.plans, this.snapshot.event);
+            this.docs.setRows(this.rows, this.snapshot.event, this.docs.selected?.key);
             this.syncDetail();
             this.tui.requestRender();
         });
     }
+    /** A filter never re-plans: it is a question about the plan already computed,
+     *  which is what keeps a facet change instant on a corpus this size. */
+    setFilters(next) {
+        this.filters = next;
+        this.docs.setFilters(next);
+        this.syncDetail();
+    }
     syncDetail() {
         const row = this.docs.selected;
         const capOwner = row === undefined ? null : capOwnerFor(row.anchor, this.snapshot.profileId);
@@ -124,8 +149,8 @@ export class ContextAdminShell {
             this.handleModal(data);
             return;
         }
-        if (this.docs.ownsKeyboard && this.docs.handleInput(data)) {
-            this.syncDetail();
+        if (this.searching) {
+            this.handleSearch(data);
             return;
         }
         const step = this.cyclesEvent(data);
@@ -137,32 +162,48 @@ export class ContextAdminShell {
             this.close();
             return;
         }
-        if (this.zone === 'axes')
-            this.handleAxes(data);
+        if (this.zone === 'rail')
+            this.handleRail(data);
         else if (this.zone === 'docs')
             this.handleDocs(data);
         else
             this.handleDetail(data);
     }
-    handleAxes(data) {
+    /** The rail's rows are the snapshot axes followed by the filter facets, so
+     *  one cursor and one gesture drive both sections. */
+    handleRail(data) {
         const axes = axesOf(this.snapshot, profileNameFor(this.snapshot.profileId) ?? 'none');
-        this.axisIndex = Math.max(0, Math.min(this.axisIndex, axes.length - 1));
-        const axis = axes[this.axisIndex];
+        const facets = facetsOf(this.filters);
+        const total = axes.length + facets.length;
+        this.railIndex = Math.max(0, Math.min(this.railIndex, total - 1));
+        const axis = axes[this.railIndex];
+        const facet = facets[this.railIndex - axes.length];
+        const change = (delta) => {
+            if (axis !== undefined) {
+                if (axis.typed)
+                    this.openAxisField(axis.id, axis.label);
+                else
+                    this.setSnapshot(cycleAxis(this.snapshot, axis.id, delta));
+            }
+            else if (facet !== undefined) {
+                if (facet.typed)
+                    this.openSearch();
+                else
+                    this.setFilters(cycleFacet(this.filters, facet.id, delta));
+            }
+        };
         if (this.isDown(data)) {
-            this.axisIndex = Math.min(axes.length - 1, this.axisIndex + 1);
+            this.railIndex = Math.min(total - 1, this.railIndex + 1);
         }
         else if (this.isUp(data)) {
-            this.axisIndex = Math.max(0, this.axisIndex - 1);
+            this.railIndex = Math.max(0, this.railIndex - 1);
         }
         else if (matchesKey(data, 'space') || this.matches('crtr.setup.toggle', data)) {
-            if (axis.typed)
-                this.openAxisField(axis.id, axis.label);
-            else
-                this.setSnapshot(cycleAxis(this.snapshot, axis.id, 1));
+            change(1);
         }
         else if (this.isDescend(data)) {
-            if (matchesKey(data, 'enter') && axis.typed)
-                this.openAxisField(axis.id, axis.label);
+            if (matchesKey(data, 'enter') && (axis?.typed === true || facet?.typed === true))
+                change(1);
             else
                 this.zone = 'docs';
         }
@@ -171,11 +212,10 @@ export class ContextAdminShell {
         }
     }
     handleDocs(data) {
-        if (this.docs.handleInput(data)) {
-            this.syncDetail();
-            return;
+        if (data === '/' || matchesKey(data, '/')) {
+            this.openSearch();
         }
-        if (this.isDown(data)) {
+        else if (this.isDown(data)) {
             this.docs.move(1);
             this.syncDetail();
         }
@@ -183,18 +223,48 @@ export class ContextAdminShell {
             this.docs.move(-1);
             this.syncDetail();
         }
-        else if (matchesKey(data, 'd')) {
-            this.docs.toggleDeliveringOnly();
+        else if (matchesKey(data, 'space') || this.matches('crtr.setup.toggle', data)) {
+            this.docs.toggleGroup();
             this.syncDetail();
         }
         else if (this.isDescend(data)) {
-            if (this.docs.selected !== undefined)
+            if (this.docs.onGroup) {
+                this.docs.toggleGroup();
+                this.syncDetail();
+            }
+            else if (this.docs.selected !== undefined)
                 this.zone = 'detail';
         }
+        else if (matchesKey(data, 'escape') && this.filters.query !== '') {
+            this.setFilters({ ...this.filters, query: '' });
+        }
         else if (this.isAscend(data) || matchesKey(data, 'escape')) {
-            this.zone = 'axes';
+            this.zone = 'rail';
         }
     }
+    openSearch() {
+        this.searching = true;
+        this.zone = 'docs';
+        this.tui.requestRender();
+    }
+    /** Typing filters live, so the field is the list's own heading rather than a
+     *  modal over the rows it is selecting. */
+    handleSearch(data) {
+        if (matchesKey(data, 'escape')) {
+            this.searching = false;
+            this.setFilters({ ...this.filters, query: '' });
+        }
+        else if (matchesKey(data, 'enter')) {
+            this.searching = false;
+        }
+        else if (matchesKey(data, 'backspace')) {
+            this.setFilters({ ...this.filters, query: this.filters.query.slice(0, -1) });
+        }
+        else if (data.length === 1 && data.charCodeAt(0) >= 32) {
+            this.setFilters({ ...this.filters, query: this.filters.query + data });
+        }
+        this.tui.requestRender();
+    }
     handleDetail(data) {
         if (this.isDown(data))
             this.detail.move(1);
@@ -570,15 +640,15 @@ export class ContextAdminShell {
             return theme.fg('dim', 'y/enter confirm · n/esc cancel');
         if (this.modal?.kind === 'field')
             return theme.fg('dim', 'type · enter apply · esc cancel');
-        if (this.docs.ownsKeyboard)
-            return theme.fg('dim', 'type to filter · enter keep · esc clear');
+        if (this.searching)
+            return theme.fg('dim', 'type to search names · enter keep · esc clear');
         if (this.notice !== undefined)
             return theme.fg(this.notice.ok ? 'success' : 'warning', truncateToWidth(this.notice.text, width));
         const move = `${this.label('crtr.setup.list-down', 'j')}/${this.label('crtr.setup.list-up', 'k')}`;
-        const left = this.zone === 'axes'
-            ? `${move} axis · space change · enter documents`
+        const left = this.zone === 'rail'
+            ? `${move} row · space change · enter documents`
             : this.zone === 'docs'
-                ? `${move} doc · / filter · d ${this.docs.filteringDelivering ? 'all' : 'delivering'} · enter dossier`
+                ? `${move} row · space ${this.docs.onGroup ? 'open group' : 'group'} · / search · enter dossier`
                 : `${move} field · enter edit · e add · x remove · g gate · b body · u unlisted · s slash · m cap · r rename`;
         const right = `${this.label('crtr.setup.tab-next', 'tab')} event · ${this.label('crtr.setup.cancel', 'q')} close`;
         const gap = width - visibleWidth(left) - visibleWidth(right);
@@ -591,14 +661,26 @@ export class ContextAdminShell {
         const bodyHeight = Math.max(1, height - PAGE_CHROME_ROWS);
         const railVisible = width >= RAIL_MIN_TOTAL_WIDTH;
         const axes = axesOf(this.snapshot, profileNameFor(this.snapshot.profileId) ?? 'none');
-        this.axisIndex = Math.max(0, Math.min(this.axisIndex, axes.length - 1));
+        const facets = facetsOf(this.filters);
+        this.railIndex = Math.max(0, Math.min(this.railIndex, axes.length + facets.length - 1));
+        const rail = (railWidth) => renderRail({
+            axes,
+            facets,
+            index: this.railIndex,
+            width: railWidth,
+            height: bodyHeight,
+            focused: this.zone === 'rail',
+            matched: this.docs.visibleCount,
+            total: this.rows.length,
+        });
         let body;
         if (width >= THREE_COLUMN_MIN_WIDTH) {
-            const detailWidth = Math.max(1, width - RAIL_WIDTH - DOCS_WIDTH - 6);
-            const middle = columns(this.docs.render(DOCS_WIDTH, bodyHeight, this.zone === 'docs', this.plans), DOCS_WIDTH, this.modal === undefined
+            const docsWidth = docsWidthFor(width);
+            const detailWidth = Math.max(1, width - RAIL_WIDTH - docsWidth - DIVIDER_WIDTH);
+            const middle = columns(this.docs.render(docsWidth, bodyHeight, this.zone === 'docs', this.plans), docsWidth, this.modal === undefined
                 ? this.detail.render(detailWidth, bodyHeight, this.zone === 'detail')
                 : this.renderModal(detailWidth, bodyHeight), detailWidth);
-            body = columns(renderAxes(axes, this.axisIndex, RAIL_WIDTH, bodyHeight, this.zone === 'axes'), RAIL_WIDTH, middle, width - RAIL_WIDTH - 3);
+            body = columns(rail(RAIL_WIDTH), RAIL_WIDTH, middle, width - RAIL_WIDTH - 3);
         }
         else if (railVisible) {
             const panelWidth = width - RAIL_WIDTH - 3;
@@ -607,13 +689,13 @@ export class ContextAdminShell {
                 : this.zone === 'detail'
                     ? this.detail.render(panelWidth, bodyHeight, true)
                     : this.docs.render(panelWidth, bodyHeight, this.zone === 'docs', this.plans);
-            body = columns(renderAxes(axes, this.axisIndex, RAIL_WIDTH, bodyHeight, this.zone === 'axes'), RAIL_WIDTH, panel, panelWidth);
+            body = columns(rail(RAIL_WIDTH), RAIL_WIDTH, panel, panelWidth);
         }
         else if (this.modal !== undefined) {
             body = this.renderModal(width, bodyHeight);
         }
-        else if (this.zone === 'axes') {
-            body = renderAxes(axes, this.axisIndex, width, bodyHeight, true);
+        else if (this.zone === 'rail') {
+            body = rail(width);
         }
         else if (this.zone === 'detail') {
             body = this.detail.render(width, bodyHeight, true);
@@ -624,6 +706,7 @@ export class ContextAdminShell {
         const pending = SURFACE_EVENTS.filter((event) => this.plans.peek(event) === undefined).length;
         const meta = [
             this.snapshot.event,
+            this.costMeta(),
             pending > 0 ? `${plural(pending, 'event', 'events')} planning` : 'all events planned',
             this.edited.size > 0 ? `${plural(this.edited.size, 'doc', 'docs')} edited` : '',
         ]
@@ -631,6 +714,19 @@ export class ContextAdminShell {
             .join(' · ');
         return pageFrame({ width, height, title: 'crouter context', meta, body, footer: this.footer(width) });
     }
+    /** What the delivering documents spend on this event. An estimate, and a
+     *  floor on the rendered prompt: boot wraps these documents in its own intro
+     *  prose and catalog tree. */
+    costMeta() {
+        const { total, byRung } = costTotals(this.rows, this.snapshot.event);
+        if (total === 0)
+            return 'no documents delivered';
+        const split = ['content', 'preview', 'name']
+            .filter((rung) => byRung[rung] > 0)
+            .map((rung) => `${formatCost(byRung[rung]).replace('~', '')} ${rung}`)
+            .join(' · ');
+        return `docs load ${formatCost(total)} — ${split}`;
+    }
 }
 /** Every field here is an edit-or-accept, never a blank to retype, so the
  *  cursor lands at the end (`\x05`) — `setValue` alone leaves it at 0, where

package/dist/commands/sys/daemon.js

@@ -80,7 +80,7 @@ const daemonRestart = defineLeaf({
         effects: [
             'The daemon acknowledges immediately, then after a short grace tears its whole broker fleet down, releases its claim, spawns a successor on the runtime generation currently selected, and exits.',
             'Each torn-down broker hands its foreground bash commands to the file-backed background job system; they keep running and report completion by urgent inbox message.',
-            'Every node it tore down — including the caller — is resumed by the successor through the ordinary startup recovery sweep.',
+            'Every node it tore down — including the caller — is resolved by the successor through the ordinary row-driven supervision tick.',
             'The calling process is killed as part of that teardown, AFTER this result is returned.',
         ],
     },

package/dist/core/__tests__/child-death-wake.test.js

@@ -1,30 +1,4 @@
 // Run with: node --import tsx/esm --test src/core/__tests__/child-death-wake.test.ts
-//
-// DOCTRINE WAKE — "a parent that delegated and went dormant is still woken when
-// its child reaches a genuine terminal outcome, and is NEVER spuriously woken on
-// healthy dormancy." Drives the REAL daemon decision pass (superviseTick) + the
-// REAL closeNode against canvas rows fabricated DIRECTLY in an isolated home — NO
-// real tmux session, NO broker boot.
-//
-// BROKER CUT (this worktree): the daemon's OLD parent-wake mechanism is GONE.
-// U7 deleted surfaceChildDeath and the entire pane-gone reaping block (the
-// crash/finalize/release routing that used to mark a pane-gone child dead/done/
-// idle and fan a system inbox entry to its subscribers). Under exit-event
-// authority a viewer pane/window closing is NOT a node death, and the tick runs
-// no liveness pass at all — a booted child's death is observed only through its
-// broker's real exit event (fleet exit-policy job), which recovery-revives it
-// on its saved session rather than surfacing it as dead. The doctrine wake
-// therefore RELOCATED off the daemon's tick:
-//   • child finishes → `crtr push final` wakes subscribers via the PUSH itself;
-//   • child crashes → its exit event drives a recovery revive (it comes back
-//     and pushes later);
-//   • child never boots → the exit event terminalizes it and surfaceBootFailure
-//     pushes urgent (daemon-boot.test);
-//   • child `node close`d → close.ts fans the child-closed wake (tested below).
-// So the daemon now fans NO liveness wake at all, which makes the old CRUX
-// (healthy dormancy must not wake the parent) hold by construction. This file
-// locks in (a) the new pid-only non-reaping + no-daemon-wake contract, and (b)
-// the one genuine-terminal wake that still lives in core: close.ts.
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
@@ -112,15 +86,6 @@ after(() => {
     delete process.env['CRTR_HOME'];
     resetFleetForTests();
 });
-// BROKER CUT — exit-event authority REPLACES daemon pane-gone reaping. A booted
-// child whose engine pid is dead (and whose viewer pane is gone) is RECOVERED,
-// not reaped, and the daemon's tick fans NO wake to the dormant parent. This
-// single case subsumes the four deleted scenarios (crash / quiet-finalize /
-// awaiting a live grandchild / pending self-wake): with pane state ignored and
-// surfaceChildDeath gone, the daemon treats them all identically — no reap, no
-// liveness wake — so the old CRUX (no spurious wake on healthy dormancy) holds
-// by construction. The node-lifecycle tick relaunches the row through the same
-// policy table its exit event would have used (D-12); that recovery is silent.
 test('exit-event authority: a dead-engine booted child is recovered, NOT reaped, and the tick fans NO wake to its dormant parent', async () => {
     const originalLaunch = headlessBrokerHost.launch;
     const launches = [];
@@ -139,9 +104,6 @@ test('exit-event authority: a dead-engine booted child is recovered, NOT reaped,
         // its saved session, never reaped to dead/done/idle.
         assert.deepEqual(launches, ['CHILD'], 'the tick recovers the dead engine through the policy table');
         assert.equal(getNode('CHILD').status, 'active', 'CHILD is recovered, NOT reaped');
-        // surfaceChildDeath is deleted: the daemon raises no liveness wake. The
-        // doctrine wake now rides the child's own `push final` (or close.ts), so a
-        // purely-inbox-waiting parent is never spuriously woken on dormancy/crash.
         assert.equal(readInboxSince('PARENT').length, 0, 'PARENT inbox EMPTY — no daemon liveness wake');
     }
     finally {
@@ -163,13 +125,3 @@ test('node close of a child wakes its SURVIVING manager (the parent outside the
     assert.ok(wake, 'node close fanned a child-closed entry to the surviving manager (D-1: previously none)');
     assert.match(wake.label, /closed/i, 'the entry names the closed child');
 });
-// NOTE (broker cut): the two NEGATIVE "CRUX" tests that used to live here — a
-// child dormant while awaiting a live grandchild, and a child dormant on a
-// pending self-wake — asserted the daemon's pane-gone routing chose idle-release
-// (status 'idle', intent 'idle-release') over finalize, so it would not spuriously
-// wake the parent. U7 DELETED that routing entirely: pane state is ignored, the
-// daemon never finalizes/releases on liveness, and surfaceChildDeath is gone, so
-// the daemon raises no liveness wake at all. The no-spurious-wake invariant they
-// protected now holds by construction and is covered by the pid-only test above
-// (PARENT inbox stays empty). Removed rather than adapted because the
-// idle-release-vs-finalize distinction they asserted no longer exists.