@crouton-kit/crouter 0.3.28 → 0.3.30

package/dist/core/canvas/browse/app.js

@@ -9,10 +9,14 @@
 // `pi --session` directly (see canvas-resume.ts header for the desync hazard).
 import { execFileSync } from 'node:child_process';
 import { resolve } from 'node:path';
-import { dashboardRowsAll, renderForest } from '../render.js';
-import { listNodes, subscriptionsOf } from '../canvas.js';
+import { dashboardRowsAll, enrichRows, loadPreview, renderForest } from '../render.js';
+import { listNodes, subscriptionsOf, getNode } from '../canvas.js';
+import { closeNode } from '../../runtime/close.js';
 import { setupTerminal, restoreTerminal, getTerminalSize, parseKeypress, } from '../../tui/terminal.js';
-import { buildTree, flatten, TABS, SORTS } from './model.js';
+import { buildTree, flatten, TABS } from './model.js';
+// Sort cycle for the `s` key. Starts on the default `attention` ordering; one `s`
+// press restores the structural `tree` view, then relevance/recency, then back.
+const SORT_CYCLE = ['attention', 'tree', 'relevance', 'recency'];
 import { renderFrame, detectColorCaps, headerHeight, PREVIEW_HEIGHT } from './render.js';
 /** Viewport (body) height = total rows minus the header renderFrame draws (see
  *  render.ts headerHeight), the footer, and the preview panel when shown. Kept
@@ -50,11 +54,16 @@ export async function runBrowse(opts = {}) {
         search: false,
         scrollOffset: 0,
         cwdScope: launchCwd, // default: this dir
-        sort: 'tree',
+        sort: 'attention', // default: attention ordering (attached/streaming/live first)
         preview: true, // default ON (decision)
         residentsOnly: true, // default ON: hide one-shot workers (decision)
+        pendingClose: null,
     };
     let visible = [];
+    // The DashboardRow ref the tree holds for a visible id. Enrichment mutates this
+    // object in place, so a later renderFrame (reading off the same tree) re-renders
+    // the upgraded label/ctx/preview without a re-snapshot.
+    const rowOf = (id) => tree.nodes.get(id)?.row;
     // Color capability is fixed for the session (it's a property of the tty/env).
     const caps = detectColorCaps();
     // Restore the terminal exactly once, however we leave (quit, resume, crash).
@@ -114,11 +123,29 @@ export async function runBrowse(opts = {}) {
             state.scrollOffset = state.cursor - viewport + 1;
         if (state.scrollOffset < 0)
             state.scrollOffset = 0;
+        // Lazy paint: enrich only the rows about to be drawn (full label + ctx + asks),
+        // and load the selected row's preview. Both are idempotent (guard-flagged), so
+        // calling them every flush is cheap once a row is warm.
+        const top = state.scrollOffset;
+        const bottom = Math.min(visible.length, top + viewport);
+        const slice = [];
+        for (let i = top; i < bottom; i++) {
+            const r = rowOf(visible[i].id);
+            if (r !== undefined)
+                slice.push(r);
+        }
+        enrichRows(slice);
+        const cur = curRow();
+        if (cur !== undefined) {
+            const r = rowOf(cur.id);
+            if (r !== undefined)
+                loadPreview(r);
+        }
         const frame = renderFrame({
             tree, visible, tab: state.tab, cursor: state.cursor, scrollOffset: state.scrollOffset,
             query: state.query, search: state.search, totalNodes,
             cwdScope: state.cwdScope, sort: state.sort, preview: state.preview,
-            residentsOnly: state.residentsOnly,
+            residentsOnly: state.residentsOnly, pendingClose: state.pendingClose,
         }, size, caps);
         process.stdout.write(frame);
     };
@@ -128,6 +155,50 @@ export async function runBrowse(opts = {}) {
     };
     const curRow = () => visible[state.cursor];
     const isExpanded = (id) => !state.collapsed.has(id);
+    // Every node in the snapshot subtree rooted at `id` (the node + all its tree
+    // descendants), used by the close-out streaming check.
+    const subtreeIds = (id) => {
+        const out = [];
+        const stack = [id];
+        const seen = new Set();
+        while (stack.length > 0) {
+            const cur = stack.pop();
+            if (seen.has(cur))
+                continue;
+            seen.add(cur);
+            out.push(cur);
+            for (const c of tree.nodes.get(cur)?.childIds ?? [])
+                stack.push(c);
+        }
+        return out;
+    };
+    // Is the node, or any descendant, GENUINELY mid-turn right now (from the snapshot)?
+    const anyStreaming = (id) => subtreeIds(id).some((x) => tree.nodes.get(x)?.row.streaming === true);
+    // Close-out (`x`): finalize the node to `done`, cascade-cancel its exclusive
+    // subtree, tear down each engine, and detach every attached viewer. Then reflect
+    // the new terminal statuses back into the live snapshot so the row updates in
+    // place (no re-snapshot). Best-effort: a teardown failure never wedges the picker.
+    const doClose = (id) => {
+        state.pendingClose = null;
+        let closed = [];
+        try {
+            closed = closeNode(id, { rootEvent: 'finalize' }).closed;
+        }
+        catch {
+            return; // unknown/already-gone node — nothing to reflect
+        }
+        for (const cid of closed) {
+            const n = tree.nodes.get(cid);
+            if (n === undefined)
+                continue;
+            const m = getNode(cid);
+            if (m !== null)
+                n.row.status = m.status; // real post-close status (done / canceled)
+            n.row.streaming = false;
+            n.row.viewed = false;
+        }
+        recompute(id);
+    };
     const cycleTab = (dir) => {
         const i = TABS.indexOf(state.tab);
         state.tab = TABS[(i + dir + TABS.length) % TABS.length];
@@ -135,11 +206,12 @@ export async function runBrowse(opts = {}) {
         state.scrollOffset = 0;
         recompute();
     };
-    // Cycle sort (tree → relevance → recency), keeping the selected node put.
+    // Cycle sort (attention → tree → relevance → recency → attention), keeping the
+    // selected node put. One `s` from the default `attention` lands on `tree`.
     const cycleSort = () => {
         const keep = curRow()?.id;
-        const i = SORTS.indexOf(state.sort);
-        state.sort = SORTS[(i + 1) % SORTS.length];
+        const i = SORT_CYCLE.indexOf(state.sort);
+        state.sort = SORT_CYCLE[(i + 1) % SORT_CYCLE.length];
         recompute(keep);
     };
     // Toggle cwd scope between the launch dir and All dirs (no-op if launch dir
@@ -204,6 +276,19 @@ export async function runBrowse(opts = {}) {
                 quit();
             return;
         }
+        // Close-out confirm sub-state: a streaming node is awaiting y/n. Swallow every
+        // other key so the confirm is modal.
+        if (state.pendingClose !== null) {
+            if (input === 'y' || input === 'Y') {
+                doClose(state.pendingClose);
+                flush();
+                return;
+            }
+            // n / Esc / anything else cancels the close.
+            state.pendingClose = null;
+            flush();
+            return;
+        }
         const row = curRow();
         // Quit.
         if (input === 'q' || key.escape)
@@ -294,6 +379,18 @@ export async function runBrowse(opts = {}) {
             flush();
             return;
         }
+        // Close-out the selected node (+ its exclusive subtree). If anything in that
+        // subtree is actively streaming, confirm first (y/n); otherwise close at once.
+        if (input === 'x') {
+            if (row !== undefined) {
+                if (anyStreaming(row.id))
+                    state.pendingClose = row.id;
+                else
+                    doClose(row.id);
+            }
+            flush();
+            return;
+        }
         // Sort / scope / residents / preview.
         if (input === 's') {
             cycleSort();
@@ -350,6 +447,32 @@ export async function runBrowse(opts = {}) {
     }
     setupTerminal();
     flush();
+    // Background corpus warmer: after the instant first paint, progressively enrich
+    // + load-preview every row (in small chunks, off the event loop) so the prompt
+    // super-search corpus lights up shortly after the instant name/kind/id search.
+    // Mutates row objects only; re-flushes solely while a live search is open so new
+    // matches surface. Stops as soon as the terminal is restored (quit/resume/crash).
+    const warmRows = [...tree.nodes.values()].map((n) => n.row);
+    let warmIdx = 0;
+    const WARM_CHUNK = 30;
+    const warmChunk = () => {
+        if (restored)
+            return;
+        const end = Math.min(warmIdx + WARM_CHUNK, warmRows.length);
+        const slice = warmRows.slice(warmIdx, end);
+        enrichRows(slice);
+        for (const r of slice)
+            loadPreview(r);
+        warmIdx = end;
+        // A live search may match the freshly-warmed prompts → recompute + repaint.
+        if (state.search && state.query !== '') {
+            recompute(curRow()?.id);
+            flush();
+        }
+        if (warmIdx < warmRows.length)
+            setImmediate(warmChunk);
+    };
+    setImmediate(warmChunk);
     await new Promise(() => {
         const onData = (data) => {
             try {

package/dist/core/canvas/browse/model.d.ts

@@ -4,9 +4,11 @@ export type Tab = 'All' | 'Live' | 'Dormant' | 'Flagged';
 export declare const TABS: readonly Tab[];
 /** How the visible rows are ordered.
  *    tree      — spanning-tree order, ancestors shown for context (the default).
+ *    attention — FLAT list, tiered by where your attention belongs (attached/
+ *                streaming/live), newest-message-first within each tier.
  *    relevance — FLAT list, best query match first (super-search).
  *    recency   — FLAT list, newest `created` first. */
-export type SortMode = 'tree' | 'relevance' | 'recency';
+export type SortMode = 'tree' | 'attention' | 'relevance' | 'recency';
 export declare const SORTS: readonly SortMode[];
 /** Does a node belong to this tab's slice?
  *    All      — every node.
@@ -88,6 +90,22 @@ export declare function fieldScore(query: string, text: string): number;
 /** Weighted relevance of a row to the query across all searched fields. 0 means
  *  no field matched (excluded from relevance results, same as `queryMatch`). */
 export declare function scoreRow(query: string, row: DashboardRow): number;
+/** The "most recent message" signal for the attention sort: the pi session-file
+ *  mtime (ms) the snapshot stamps on each row, falling back to the `created`
+ *  birth timestamp when no session file exists. Larger = more recent.
+ *
+ *  NOTE (phase-3 reconcile): phase 1 owns the field name on DashboardRow. We read
+ *  `mtimeMs` here as the most likely name; if phase 1 lands a different name,
+ *  update this single accessor. `created` is ISO 8601, so its epoch-ms is a
+ *  monotonic stand-in within the same tier. */
+export declare function attentionMtime(row: DashboardRow): number;
+/** Attention tier (lower = higher priority, shown first):
+ *    T0 — attached AND streaming (`viewed && streaming`)
+ *    T1 — attached, not streaming (`viewed`)
+ *    T2 — streaming, not attached
+ *    T3 — live but neither (`status active|idle`)
+ *    T4 — everything else (dormant: done/dead/canceled). */
+export declare function attentionTier(row: DashboardRow): number;
 export interface VisibleRow {
     id: string;
     depth: number;
@@ -103,10 +121,10 @@ export interface FlattenOpts {
      *  undefined = All dirs (no cwd filter). Like the tab predicate, it gates the
      *  matched set — ancestors from other dirs still render dimmed for tree context. */
     cwdScope?: string | null;
-    /** Lifecycle filter: when true, hide `terminal` (one-shot worker) nodes so only
-     *  the persistent `resident` agents you come back to show. The resume picker
-     *  defaults this ON. Undefined/false = every lifecycle. Gates the matched set
-     *  like the tab + cwd predicates (ancestors of a match still render for context). */
+    /** Lifecycle filter: when true, `terminal` (one-shot worker) nodes are kept out
+     *  of the TOP-LEVEL rows and the flat search results — but, in tree mode, still
+     *  appear when you manually expand their parent fold (drilling into a resident).
+     *  The resume picker defaults this ON. Undefined/false = every lifecycle. */
     residentsOnly?: boolean;
     /** Ordering. `tree` keeps the spanning tree + ancestor context; `relevance` /
      *  `recency` produce a FLAT ranked list of directly-matched rows. */

package/dist/core/canvas/browse/model.js

@@ -5,7 +5,7 @@
 // access (dashboardRowsAll / listNodes / subscriptionsOf) into buildTree, then
 // drives flatten() on each keystroke.
 export const TABS = ['All', 'Live', 'Dormant', 'Flagged'];
-export const SORTS = ['tree', 'relevance', 'recency'];
+export const SORTS = ['tree', 'attention', 'relevance', 'recency'];
 /** Does a node belong to this tab's slice?
  *    All      — every node.
  *    Live     — active | idle.
@@ -287,6 +287,43 @@ export function scoreRow(query, row) {
         FIELD_WEIGHTS.id * fieldScore(query, shortId(row.node_id)) +
         FIELD_WEIGHTS.prompt * (prompt !== '' ? fieldScore(query, prompt) : 0));
 }
+// ---------------------------------------------------------------------------
+// Attention tiering (default sort)
+// ---------------------------------------------------------------------------
+/** The "most recent message" signal for the attention sort: the pi session-file
+ *  mtime (ms) the snapshot stamps on each row, falling back to the `created`
+ *  birth timestamp when no session file exists. Larger = more recent.
+ *
+ *  NOTE (phase-3 reconcile): phase 1 owns the field name on DashboardRow. We read
+ *  `mtimeMs` here as the most likely name; if phase 1 lands a different name,
+ *  update this single accessor. `created` is ISO 8601, so its epoch-ms is a
+ *  monotonic stand-in within the same tier. */
+export function attentionMtime(row) {
+    const m = row.mtimeMs;
+    if (typeof m === 'number' && Number.isFinite(m))
+        return m;
+    const t = Date.parse(row.created);
+    return Number.isFinite(t) ? t : 0;
+}
+/** Attention tier (lower = higher priority, shown first):
+ *    T0 — attached AND streaming (`viewed && streaming`)
+ *    T1 — attached, not streaming (`viewed`)
+ *    T2 — streaming, not attached
+ *    T3 — live but neither (`status active|idle`)
+ *    T4 — everything else (dormant: done/dead/canceled). */
+export function attentionTier(row) {
+    const viewed = row.viewed === true;
+    const streaming = row.streaming === true;
+    if (viewed && streaming)
+        return 0;
+    if (viewed)
+        return 1;
+    if (streaming)
+        return 2;
+    if (row.status === 'active' || row.status === 'idle')
+        return 3;
+    return 4;
+}
 /** Is this row inside the active cwd scope? No scope (null/undefined) = All dirs. */
 export function cwdMatch(scope, row) {
     return scope === null || scope === undefined || row.cwd === scope;
@@ -312,13 +349,19 @@ export function lifecycleMatch(residentsOnly, row) {
 export function flatten(tree, opts) {
     const { collapsed, tab, query, cwdScope, residentsOnly, sort = 'tree' } = opts;
     // 1. Directly-matched nodes: tab predicate AND cwd scope AND lifecycle AND query.
+    //    `matched` honors the residents-only filter (drives top-level rows, ancestor
+    //    context, force-expand, and the flat search results below). `matchedAll` is
+    //    the same set WITHOUT the lifecycle gate — it's how a terminal node becomes
+    //    visible once you expand the resident parent that owns it (the fold-reveal
+    //    below), so residents-only de-clutters the top level + search yet still lets
+    //    you drill into a fold and see everything under it.
     const matched = new Set();
+    const matchedAll = new Set();
     for (const [id, node] of tree.nodes) {
-        if (tabPredicate(tab, node.row) &&
-            cwdMatch(cwdScope, node.row) &&
-            lifecycleMatch(residentsOnly, node.row) &&
-            queryMatch(query, node.row)) {
-            matched.add(id);
+        if (tabPredicate(tab, node.row) && cwdMatch(cwdScope, node.row) && queryMatch(query, node.row)) {
+            matchedAll.add(id);
+            if (lifecycleMatch(residentsOnly, node.row))
+                matched.add(id);
         }
     }
     // FLAT ranked modes (relevance / recency): no tree, no ancestors — just the
@@ -328,7 +371,14 @@ export function flatten(tree, opts) {
         const ids = [...matched];
         const createdOf = (id) => tree.nodes.get(id)?.row.created ?? '';
         const byRecency = (a, b) => createdOf(b).localeCompare(createdOf(a));
-        if (sort === 'recency' || query === '') {
+        if (sort === 'attention') {
+            // Tiered (attached/streaming/live first), newest-message-first within tier.
+            const rowOf = (id) => tree.nodes.get(id).row;
+            ids.sort((a, b) => (attentionTier(rowOf(a)) - attentionTier(rowOf(b))) ||
+                (attentionMtime(rowOf(b)) - attentionMtime(rowOf(a))) ||
+                byRecency(a, b));
+        }
+        else if (sort === 'recency' || query === '') {
             ids.sort(byRecency);
         }
         else {
@@ -354,14 +404,19 @@ export function flatten(tree, opts) {
             return true; // force-expand to reveal matches
         return !collapsed.has(id);
     };
-    // 3. Walk the tree in order, emitting included nodes and descending only into
-    //    expanded ones.
+    // 3. Walk the tree in order, emitting shown nodes and descending only into
+    //    expanded ones. A node is shown when it is `included` (matched or ancestor),
+    //    OR — under residents-only — when its already-shown parent is expanded and the
+    //    node matches everything but the lifecycle gate (`matchedAll`). That is the
+    //    fold-reveal: a terminal worker hidden from the top level reappears the moment
+    //    you open the resident fold that owns it. `parentShown` threads that down.
     const out = [];
-    const walk = (id) => {
+    const walk = (id, parentShown) => {
         const node = tree.nodes.get(id);
         if (node === undefined)
             return;
-        if (included(id)) {
+        const show = included(id) || (residentsOnly === true && parentShown && matchedAll.has(id));
+        if (show) {
             const hasChildren = node.childIds.length > 0;
             out.push({
                 id,
@@ -373,10 +428,10 @@ export function flatten(tree, opts) {
         }
         if (isExpanded(id)) {
             for (const c of node.childIds)
-                walk(c);
+                walk(c, show);
         }
     };
     for (const r of tree.roots)
-        walk(r);
+        walk(r, false);
     return out;
 }

package/dist/core/canvas/browse/render.d.ts

@@ -2,7 +2,9 @@ import type { Tab, Tree, VisibleRow, SortMode } from './model.js';
 import { detectColorCaps, type ColorCaps } from '../../tui/draw.js';
 export { detectColorCaps };
 export type { ColorCaps };
-export declare const PREVIEW_BODY = 5;
+export declare const PROMPT_LINES = 3;
+export declare const REPLY_LINES = 3;
+export declare const PREVIEW_BODY: number;
 export declare const PREVIEW_HEIGHT: number;
 export declare function headerHeight(search: boolean): number;
 export interface RenderState {
@@ -23,6 +25,10 @@ export interface RenderState {
     /** Lifecycle filter: when true, `terminal` (one-shot worker) nodes are hidden
      *  — surfaced as a status-line cue. */
     residentsOnly: boolean;
+    /** When set, a close-out (`x`) is awaiting y/n confirmation because the node (or
+     *  a descendant) is actively streaming. Holds the node id being confirmed; the
+     *  footer becomes the y/n prompt. null/undefined = no pending confirm. */
+    pendingClose?: string | null;
 }
 /**
  * Render the whole frame. Returns a single string that, written as-is, repaints