@north-light/crouter 0.3.242 → 0.3.243

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

@@ -26,27 +26,37 @@ export declare class ContextDocsPanel {
     private event;
     private lines;
     private index;
-    /** Groups the user opened. Empty means every group is collapsed, which is how
-     *  the page opens: ~25 rows that name the whole corpus. */
+    /** Directories the user opened, by full name prefix. Empty means every level
+     *  is collapsed, which is how the page opens: ~25 rows that name the whole
+     *  corpus. */
     private readonly expanded;
     constructor(onChange: () => void);
     /** The document the dossier describes: the focused row, or the first member
      *  of the focused group so the dossier is never blank. */
     get selected(): DocRow | undefined;
-    /** Documents the current question selects — counted from the group rollups,
-     *  so a fully collapsed list still reports its size. */
+    /** Documents the current question selects — counted from the top-level
+     *  rollups, which partition the corpus, so a fully collapsed list still
+     *  reports its size and a nested rollup is never counted twice. */
     get visibleCount(): number;
     setRows(rows: DocRow[], event: SurfaceEvent, selectedKey?: string): void;
     setFilters(filters: Filters): void;
     move(delta: number): void;
-    /** True when the focused line is a group, so the shell knows whether a
-     *  descend opens a group or the dossier. */
+    /** True when the focused line can be opened — a directory header. */
     get onGroup(): boolean;
+    /** True when the focused line IS a document rather than merely standing for
+     *  one. A directory that is also a document is both, which is why the two
+     *  gestures split there: space opens it, enter edits it. */
+    get onDocument(): boolean;
     toggleGroup(): void;
     /** Rebuild the drawn lines, keeping the cursor on the same document (or the
-     *  same group), and clamping when what it was on is gone. */
+     *  same directory), and clamping when what it was on is gone. A document that
+     *  owns a directory is drawn as that directory's header, so a held document
+     *  key matches there too. */
     private relayout;
     render(width: number, height: number, focused: boolean, plans: PlanSet): string[];
+    /** A directory header. Its stats and cost are the whole subtree's; the matrix
+     *  is drawn only when the directory is itself a document, which is what marks
+     *  the one row as both a document and a directory. */
     private groupLine;
     private docLine;
     /** Pad rather than trim: this column sets the length of the divider drawn

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

@@ -1,7 +1,7 @@
-// The middle column: every document the snapshot can see, grouped by the first
-// segment of its canonical name and 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.
+// The middle column: every document the snapshot can see, grouped recursively
+// by the directories its canonical name names, and 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 { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 import { padAnsi, theme, visibleRange } from '../../../../core/tui/panel.js';
 import { SURFACE_EVENTS } from '../../../../core/substrate/schema.js';
@@ -50,6 +50,9 @@ const COST_WIDTH = 6;
 /** The glyphs a group header counts its members with — the matrix vocabulary,
  *  so a rung reads the same in both columns. */
 const RUNG_MARK = { content: '█', preview: '▄', name: '▁' };
+/** Columns one nesting level spends, so a doc sits under its directory's label
+ *  and the truncator sees the indent as part of the name it is eliding. */
+const INDENT = 2;
 export class ContextDocsPanel {
     onChange;
     rows = [];
@@ -57,8 +60,9 @@ export class ContextDocsPanel {
     event = 'boot';
     lines = [];
     index = 0;
-    /** Groups the user opened. Empty means every group is collapsed, which is how
-     *  the page opens: ~25 rows that name the whole corpus. */
+    /** Directories the user opened, by full name prefix. Empty means every level
+     *  is collapsed, which is how the page opens: ~25 rows that name the whole
+     *  corpus. */
     expanded = new Set();
     constructor(onChange) {
         this.onChange = onChange;
@@ -71,10 +75,11 @@ export class ContextDocsPanel {
             return undefined;
         return line.kind === 'doc' ? line.row : line.first;
     }
-    /** Documents the current question selects — counted from the group rollups,
-     *  so a fully collapsed list still reports its size. */
+    /** Documents the current question selects — counted from the top-level
+     *  rollups, which partition the corpus, so a fully collapsed list still
+     *  reports its size and a nested rollup is never counted twice. */
     get visibleCount() {
-        return this.lines.reduce((count, line) => count + (line.kind === 'group' ? line.docs : 0), 0);
+        return this.lines.reduce((count, line) => count + (line.kind === 'group' && line.depth === 0 ? line.docs : 0), 0);
     }
     setRows(rows, event, selectedKey) {
         this.rows = rows;
@@ -95,11 +100,17 @@ export class ContextDocsPanel {
         this.index = Math.max(0, Math.min(this.lines.length - 1, this.index + delta));
         this.onChange();
     }
-    /** True when the focused line is a group, so the shell knows whether a
-     *  descend opens a group or the dossier. */
+    /** True when the focused line can be opened — a directory header. */
     get onGroup() {
         return this.lines[this.index]?.kind === 'group';
     }
+    /** True when the focused line IS a document rather than merely standing for
+     *  one. A directory that is also a document is both, which is why the two
+     *  gestures split there: space opens it, enter edits it. */
+    get onDocument() {
+        const line = this.lines[this.index];
+        return line !== undefined && (line.kind === 'doc' || line.isDoc);
+    }
     toggleGroup() {
         const line = this.lines[this.index];
         if (line?.kind !== 'group')
@@ -112,7 +123,9 @@ export class ContextDocsPanel {
         this.onChange();
     }
     /** Rebuild the drawn lines, keeping the cursor on the same document (or the
-     *  same group), and clamping when what it was on is gone. */
+     *  same directory), and clamping when what it was on is gone. A document that
+     *  owns a directory is drawn as that directory's header, so a held document
+     *  key matches there too. */
     relayout(selectedKey, groupKey) {
         const held = selectedKey ?? (this.lines[this.index]?.kind === 'doc' ? this.lines[this.index].key : undefined);
         this.lines = buildListView(this.rows, this.filters, this.expanded, this.event);
@@ -120,7 +133,7 @@ export class ContextDocsPanel {
             ? this.lines.findIndex((line) => line.kind === 'group' && line.key === groupKey)
             : held === undefined
                 ? -1
-                : this.lines.findIndex((line) => line.kind === 'doc' && line.key === held);
+                : this.lines.findIndex((line) => (line.kind === 'doc' && line.key === held) || (line.kind === 'group' && line.isDoc && line.first.key === held));
         this.index = wanted >= 0 ? wanted : Math.max(0, Math.min(this.index, this.lines.length - 1));
     }
     render(width, height, focused, plans) {
@@ -140,7 +153,7 @@ export class ContextDocsPanel {
         const range = visibleRange(this.lines.length, this.index, capacity);
         for (let at = range.start; at < range.end; at += 1) {
             const line = this.lines[at];
-            const body = line.kind === 'group' ? this.groupLine(line, nameRoom) : this.docLine(line, nameRoom, plans);
+            const body = line.kind === 'group' ? this.groupLine(line, nameRoom, plans) : this.docLine(line, nameRoom, plans);
             out.push(at === this.index && focused
                 ? theme.bg('selectedBg', padAnsi(body, width))
                 : at === this.index
@@ -149,9 +162,12 @@ export class ContextDocsPanel {
         }
         return this.fit(out, height);
     }
-    groupLine(line, nameRoom) {
+    /** A directory header. Its stats and cost are the whole subtree's; the matrix
+     *  is drawn only when the directory is itself a document, which is what marks
+     *  the one row as both a document and a directory. */
+    groupLine(line, nameRoom, plans) {
         const marker = line.expanded ? '▾' : '▸';
-        const label = `${marker} ${theme.bold(line.label)}`;
+        const label = `${' '.repeat(line.depth * INDENT)}${marker} ${theme.bold(line.label)}`;
         const marks = ['content', 'preview', 'name']
             .filter((rung) => line.rungs[rung] > 0)
             .map((rung) => `${line.rungs[rung]}${RUNG_MARK[rung]}`)
@@ -159,15 +175,12 @@ export class ContextDocsPanel {
         const stats = theme.fg('dim', marks === '' ? plural(line.docs, 'doc', 'docs') : `${line.docs} · ${marks}`);
         const room = Math.max(1, nameRoom - visibleWidth(stats) - 1);
         const field = `${padAnsi(truncateToWidth(label, room), room)} ${stats}`;
-        return ` ${padAnsi(field, nameRoom)} ${cost(line.cost)} ${' '.repeat(MATRIX_WIDTH)}`;
+        const matrix = line.isDoc ? matrixOf(line.first, plans) : ' '.repeat(MATRIX_WIDTH);
+        return ` ${padAnsi(field, nameRoom)} ${cost(line.cost)} ${matrix}`;
     }
     docLine(line, nameRoom, plans) {
-        const matrix = SURFACE_EVENTS.map((event) => {
-            const state = plans.peek(event) === undefined ? 'pending' : cellStateOf(line.row.records.get(event));
-            return cellGlyph(line.row.records.get(event), state);
-        }).join(' ');
-        const label = truncateToWidth(`  ${line.label}`, nameRoom);
-        return ` ${padAnsi(label, nameRoom)} ${cost(line.cost)} ${matrix}`;
+        const label = truncateToWidth(`${' '.repeat(line.depth * INDENT)}${line.label}`, nameRoom);
+        return ` ${padAnsi(label, nameRoom)} ${cost(line.cost)} ${matrixOf(line.row, plans)}`;
     }
     /** Pad rather than trim: this column sets the length of the divider drawn
      *  beside it. */
@@ -177,6 +190,13 @@ export class ContextDocsPanel {
         return lines.slice(0, height).map((line) => (visibleWidth(line) === 0 ? '' : line));
     }
 }
+/** One document's six events, in the order the heading names them. */
+function matrixOf(row, plans) {
+    return SURFACE_EVENTS.map((event) => {
+        const state = plans.peek(event) === undefined ? 'pending' : cellStateOf(row.records.get(event));
+        return cellGlyph(row.records.get(event), state);
+    }).join(' ');
+}
 /** Right-flushed into the cost column, dim because it is an estimate. */
 function cost(count) {
     const text = formatCost(count);

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

@@ -17,34 +17,45 @@ export interface Filters {
     query: string;
 }
 export declare const NO_FILTERS: Filters;
-/** One drawn line. A group carries what its members add up to, so a collapsed
- *  list still states where the corpus and its cost sit. */
+/** One drawn line. A group carries what its whole subtree adds up to, so a
+ *  collapsed list still states where the corpus and its cost sit. `depth` is
+ *  how many name segments sit above the line, which the renderer spends on
+ *  indent. */
 export type ListLine = {
     kind: 'group';
     key: string;
     label: string;
+    depth: number;
     docs: number;
     rungs: Record<Exclude<Rung, 'none'>, number>;
     cost: number;
     expanded: boolean;
-    /** The first member, so the dossier has a document to describe while the
-     *  cursor rests on the header. */
+    /** The document the dossier describes while the cursor rests on the
+     *  header: this directory's own document when it has one, else the first
+     *  document in its subtree. */
     first: DocRow;
+    /** True when the directory is itself a document — `first` is that
+     *  document, and the one row is both selectable and expandable. */
+    isDoc: boolean;
 } | {
     kind: 'doc';
     key: string;
     row: DocRow;
     label: string;
+    depth: number;
     cost: number;
 };
-export declare function groupKeyOf(name: string): string;
-/** Every group key the rows can produce, so collapse state can drop the keys a
- *  re-plan removed instead of accumulating them. */
+/** Every group key the rows can produce — one per proper name prefix, since a
+ *  prefix exists only because something sits under it — so collapse state can
+ *  drop the keys a re-plan removed instead of accumulating them. The leading
+ *  section is a key only when a name with no `/` owns no directory, which is
+ *  exactly when it is not itself one of those prefixes. */
 export declare function groupKeysOf(rows: readonly DocRow[]): Set<string>;
-/** The lines to draw, in corpus order: the leading section, then each group in
- *  order of first appearance. A live query force-expands every group holding a
- *  match without touching `expanded`, so clearing it restores what the user
- *  collapsed. */
+/** The lines to draw, in corpus order: the leading section, then each directory
+ *  in order of first appearance, each recursing into its own members only when
+ *  it is open. A live query force-expands every directory, which is exactly the
+ *  ancestor chain of every surviving match, without touching `expanded` — so
+ *  clearing the query restores what the user collapsed. */
 export declare function buildListView(rows: readonly DocRow[], filters: Filters, expanded: ReadonlySet<string>, event: SurfaceEvent): ListLine[];
 /** What the whole filtered set costs, split by the rung it arrives at. */
 export declare function costTotals(rows: readonly DocRow[], event: SurfaceEvent): {

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

@@ -4,78 +4,137 @@
 import { fuzzyMatch } from '../../../../core/tui/fuzzy.js';
 import { deliveredCost, rungCostsOf } from './model.js';
 export const NO_FILTERS = { rung: 'any', origin: 'any', kind: 'any', state: 'any', query: '' };
-/** Documents whose canonical name carries no `/` share one leading section
- *  rather than becoming a crowd of one-member groups. */
+/** Documents whose canonical name carries no `/` and owns no directory share
+ *  one leading section rather than becoming a crowd of one-member groups. */
 const LEADING_KEY = '';
 const LEADING_LABEL = 'top level';
-export function groupKeyOf(name) {
-    const cut = name.indexOf('/');
-    return cut < 0 ? LEADING_KEY : name.slice(0, cut);
-}
-/** Every group key the rows can produce, so collapse state can drop the keys a
- *  re-plan removed instead of accumulating them. */
+/** Every group key the rows can produce — one per proper name prefix, since a
+ *  prefix exists only because something sits under it — so collapse state can
+ *  drop the keys a re-plan removed instead of accumulating them. The leading
+ *  section is a key only when a name with no `/` owns no directory, which is
+ *  exactly when it is not itself one of those prefixes. */
 export function groupKeysOf(rows) {
-    return new Set(rows.map((row) => groupKeyOf(row.name)));
+    const keys = new Set();
+    const unslashed = [];
+    for (const row of rows) {
+        if (row.name.includes('/')) {
+            for (let cut = row.name.indexOf('/'); cut >= 0; cut = row.name.indexOf('/', cut + 1)) {
+                keys.add(row.name.slice(0, cut));
+            }
+        }
+        else
+            unslashed.push(row.name);
+    }
+    if (unslashed.some((name) => !keys.has(name)))
+        keys.add(LEADING_KEY);
+    return keys;
 }
-/** The lines to draw, in corpus order: the leading section, then each group in
- *  order of first appearance. A live query force-expands every group holding a
- *  match without touching `expanded`, so clearing it restores what the user
- *  collapsed. */
+/** The lines to draw, in corpus order: the leading section, then each directory
+ *  in order of first appearance, each recursing into its own members only when
+ *  it is open. A live query force-expands every directory, which is exactly the
+ *  ancestor chain of every surviving match, without touching `expanded` — so
+ *  clearing the query restores what the user collapsed. */
 export function buildListView(rows, filters, expanded, event) {
-    const groups = new Map();
-    const order = [];
+    const root = { key: '', segment: '', depth: -1, children: new Map(), selves: [] };
     for (const row of rows) {
         if (!passes(row, row.records.get(event), filters))
             continue;
-        const key = groupKeyOf(row.name);
-        const held = groups.get(key);
-        if (held === undefined) {
-            groups.set(key, [row]);
-            order.push(key);
+        let dir = root;
+        for (const segment of row.name.split('/')) {
+            let child = dir.children.get(segment);
+            if (child === undefined) {
+                child = {
+                    key: dir.depth < 0 ? segment : `${dir.key}/${segment}`,
+                    segment,
+                    depth: dir.depth + 1,
+                    children: new Map(),
+                    selves: [],
+                };
+                dir.children.set(segment, child);
+            }
+            dir = child;
         }
-        else
-            held.push(row);
+        dir.selves.push(row);
     }
-    if (groups.has(LEADING_KEY)) {
-        order.splice(order.indexOf(LEADING_KEY), 1);
-        order.unshift(LEADING_KEY);
+    const leading = [];
+    const dirs = [];
+    for (const child of root.children.values()) {
+        if (child.children.size === 0)
+            leading.push(...child.selves);
+        else
+            dirs.push(child);
     }
     const lines = [];
-    for (const key of order) {
-        const members = groups.get(key);
-        const rungs = { name: 0, preview: 0, content: 0 };
-        let cost = 0;
-        for (const row of members) {
-            const record = row.records.get(event);
-            if (record !== undefined && record.finalRung !== 'none')
-                rungs[record.finalRung] += 1;
-            cost += deliveredCost(record);
-        }
-        const open = filters.query !== '' || expanded.has(key);
+    if (leading.length > 0) {
+        const open = filters.query !== '' || expanded.has(LEADING_KEY);
         lines.push({
             kind: 'group',
-            key,
-            label: key === LEADING_KEY ? LEADING_LABEL : `${key}/`,
-            docs: members.length,
-            rungs,
-            cost,
+            key: LEADING_KEY,
+            label: LEADING_LABEL,
+            depth: 0,
+            ...rollup(leading, event),
             expanded: open,
-            first: members[0],
+            first: leading[0],
+            isDoc: false,
         });
-        if (!open)
-            continue;
-        for (const row of members) {
-            lines.push({
-                kind: 'doc',
-                key: row.key,
-                row,
-                label: key === LEADING_KEY ? row.name : row.name.slice(key.length + 1),
-                cost: deliveredCost(row.records.get(event)),
-            });
-        }
+        if (open)
+            for (const row of leading)
+                lines.push(docLine(row, row.name, 1, event));
     }
+    for (const dir of dirs)
+        emit(dir, filters, expanded, event, lines);
     return lines;
 }
+/** A directory's rows in drawn order: its own document first, then each child
+ *  segment's subtree — so the head of the list is also the document the header
+ *  hands the dossier. */
+function subtree(dir, out = []) {
+    out.push(...dir.selves);
+    for (const child of dir.children.values())
+        subtree(child, out);
+    return out;
+}
+function emit(dir, filters, expanded, event, lines) {
+    if (dir.children.size === 0) {
+        for (const row of dir.selves)
+            lines.push(docLine(row, dir.segment, dir.depth, event));
+        return;
+    }
+    const members = subtree(dir);
+    const open = filters.query !== '' || expanded.has(dir.key);
+    lines.push({
+        kind: 'group',
+        key: dir.key,
+        label: `${dir.segment}/`,
+        depth: dir.depth,
+        ...rollup(members, event),
+        expanded: open,
+        first: members[0],
+        isDoc: dir.selves.length > 0,
+    });
+    if (!open)
+        return;
+    // The header already stands for the first document named exactly this path;
+    // a second store answering the same name still needs its own row.
+    for (const shadowed of dir.selves.slice(1))
+        lines.push(docLine(shadowed, dir.segment, dir.depth + 1, event));
+    for (const child of dir.children.values())
+        emit(child, filters, expanded, event, lines);
+}
+function docLine(row, label, depth, event) {
+    return { kind: 'doc', key: row.key, row, label, depth, cost: deliveredCost(row.records.get(event)) };
+}
+function rollup(members, event) {
+    const rungs = { name: 0, preview: 0, content: 0 };
+    let cost = 0;
+    for (const row of members) {
+        const record = row.records.get(event);
+        if (record !== undefined && record.finalRung !== 'none')
+            rungs[record.finalRung] += 1;
+        cost += deliveredCost(record);
+    }
+    return { docs: members.length, rungs, cost };
+}
 /** What the whole filtered set costs, split by the rung it arrives at. */
 export function costTotals(rows, event) {
     const byRung = { name: 0, preview: 0, content: 0 };

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

@@ -90,6 +90,9 @@ export declare class ContextAdminShell implements Component, Focusable {
     private handleModal;
     private renderModal;
     private footer;
+    /** What the focused row does when opened. A directory answers to space, a
+     *  document to enter, and a directory that is also a document to both. */
+    private docsGesture;
     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

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

@@ -228,7 +228,9 @@ export class ContextAdminShell {
             this.syncDetail();
         }
         else if (this.isDescend(data)) {
-            if (this.docs.onGroup) {
+            // A directory that is also a document keeps both gestures: space opens it,
+            // and descending goes to its dossier like any other document.
+            if (this.docs.onGroup && !this.docs.onDocument) {
                 this.docs.toggleGroup();
                 this.syncDetail();
             }
@@ -648,7 +650,7 @@ export class ContextAdminShell {
         const left = this.zone === 'rail'
             ? `${move} row · space change · enter documents`
             : this.zone === 'docs'
-                ? `${move} row · space ${this.docs.onGroup ? 'open group' : 'group'} · / search · enter dossier`
+                ? `${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`;
         const right = `${this.label('crtr.setup.tab-next', 'tab')} event · ${this.label('crtr.setup.cancel', 'q')} close`;
         const gap = width - visibleWidth(left) - visibleWidth(right);
@@ -656,6 +658,13 @@ export class ContextAdminShell {
             ? `${theme.fg('dim', left)}${' '.repeat(gap)}${theme.fg('dim', right)}`
             : theme.fg('dim', truncateToWidth(`${left} · ${this.label('crtr.setup.cancel', 'q')} close`, width));
     }
+    /** What the focused row does when opened. A directory answers to space, a
+     *  document to enter, and a directory that is also a document to both. */
+    docsGesture() {
+        if (!this.docs.onGroup)
+            return 'enter dossier';
+        return this.docs.onDocument ? 'space open · enter dossier' : 'space/enter open';
+    }
     render(width) {
         const height = this.terminalRows();
         const bodyHeight = Math.max(1, height - PAGE_CHROME_ROWS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.242",
+  "version": "0.3.243",
   "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.242",
+  "version": "0.3.243",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.242",
+      "version": "0.3.243",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {