@north-light/crouter 0.3.214 → 0.3.216

package/dist/clients/attach/render/card-presentation.js

@@ -24,17 +24,55 @@ function extractCardSection(body, section) {
     const match = new RegExp(`<${section}\\b[^>]*>([\\s\\S]*?)</${section}>`).exec(body);
     return match ? match[1].trim() : '';
 }
+/** Body with one whole-body wrapping element removed. Envelope bodies carry
+ *  prose; a tag around all of it is framing the reader does not need. */
+const WHOLE_BODY_ELEMENT = /^<([A-Za-z][\w.:-]*)\b[^>]*>([\s\S]*)<\/\1>$/;
+function unwrapWholeBody(body) {
+    const trimmed = body.trim();
+    return (WHOLE_BODY_ELEMENT.exec(trimmed)?.[2] ?? trimmed).trim();
+}
 /** The disclosure a card actually offers, given its policy and body. A kind
  *  whose section is missing from an old transcript offers nothing to expand. */
-export function cardDisclosure(presentation, body) {
+export function cardDisclosure(presentation, card) {
     switch (presentation.expanded.disclose) {
         case 'never': return '';
-        case 'payload': return body;
-        case 'section': return extractCardSection(body, presentation.expanded.section);
+        case 'payload': return card.body;
+        case 'section': return extractCardSection(card.body, presentation.expanded.section);
+        case 'render': return presentation.expanded.render(card);
     }
 }
-export function cardIsExpandable(presentation, body) {
-    return cardDisclosure(presentation, body).length > 0;
+export function cardIsExpandable(presentation, card) {
+    return cardDisclosure(presentation, card).trim().length > 0;
+}
+/** A sender's entries read by what they are, not by the wire kind, for the two
+ *  dispositions whose kind describes the delivery rather than the message. */
+function entryLabel(entry) {
+    switch (entry.disposition) {
+        case 'human-answer': return 'answer';
+        case 'human-canceled': return 'canceled';
+        default: return entry.kind;
+    }
+}
+/** The inbox digest as Markdown: a heading per sender, then each entry's kind
+ *  and report path above its body. Both levels are headings because the theme
+ *  paints those and leaves bold at body color, so an entry label set in bold
+ *  would not separate from the prose under it. Pre-cut scrollback whose
+ *  `<from>` grammar did not parse keeps its raw body — there is nothing else
+ *  to show. */
+function inboxDisclosure(card) {
+    if (card.senders.length === 0)
+        return card.body;
+    return card.senders.map((sender) => {
+        const blocks = [`## ${sender.id}${sender.finished ? ' · finished' : ''}`];
+        for (const entry of sender.entries) {
+            const ref = entry.ref === undefined ? '' : ` · \`${entry.ref}\``;
+            blocks.push(`### ${entryLabel(entry)}${ref}`);
+            const body = entry.body.trim();
+            if (body !== '')
+                blocks.push(body);
+        }
+        return blocks.join('\n\n');
+    }).join('\n\n');
 }
 function inboxSummary(card) {
     if (card.senders.length === 0)
@@ -74,7 +112,7 @@ const CORE_CARD_PRESENTATIONS = {
     inbox: {
         subject: 'inbox',
         summary: inboxSummary,
-        expanded: PAYLOAD,
+        expanded: { disclose: 'render', render: inboxDisclosure },
         groupFolded: 'senders',
     },
     revive: {
@@ -94,19 +132,19 @@ const CORE_CARD_PRESENTATIONS = {
     'stop-guard': {
         subject: 'stop guard',
         summary: stopGuardSummary,
-        expanded: NEVER,
+        expanded: PAYLOAD,
         groupFolded: 'event',
     },
     recovery: {
         subject: 'recovery',
         summary: recoverySummary,
-        expanded: NEVER,
+        expanded: PAYLOAD,
         groupFolded: 'event',
     },
     'persona-transition': {
         subject: 'persona',
         summary: () => 'role updated',
-        expanded: NEVER,
+        expanded: { disclose: 'render', render: (card) => unwrapWholeBody(card.body) },
         groupFolded: 'event',
     },
     'review-approval': {
@@ -130,7 +168,7 @@ const CORE_CARD_PRESENTATIONS = {
     'context-nudge': {
         subject: 'context',
         summary: () => 'context-window guidance',
-        expanded: NEVER,
+        expanded: PAYLOAD,
         groupFolded: 'omit',
     },
     bearings: {

package/dist/clients/attach/render/context-message.d.ts

@@ -7,11 +7,16 @@ export declare class ContextMessageComponent implements Component {
     private expanded;
     private readonly expandable;
     private readonly labelTag;
+    private readonly summaryText;
     private readonly collapsedHint;
     private readonly expandedBody;
     constructor(card: GeneratedCard, presentation: CardPresentation, expanded: boolean, dim: (s: string) => string, label: (s: string) => string);
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded: boolean): void;
+    /** Paint the [label] tag in the accent color and the rest dim. Truncate
+     *  BEFORE painting so the ANSI wrappers never inflate the measured width — an
+     *  over-wide line aborts the whole TUI render. */
+    private headerRow;
     render(width: number): string[];
     invalidate(): void;
 }

package/dist/clients/attach/render/context-message.js

@@ -17,39 +17,45 @@ export class ContextMessageComponent {
     expanded;
     expandable;
     labelTag;
+    summaryText;
     collapsedHint;
     expandedBody;
     constructor(card, presentation, expanded, dim, label) {
         this.dim = dim;
         this.label = label;
-        this.expandable = cardIsExpandable(presentation, card.body);
+        this.expandable = cardIsExpandable(presentation, card);
         this.expanded = this.expandable && expanded;
         this.labelTag = `[${cardLabel(presentation.subject)}]`;
+        this.summaryText = ` ${presentation.summary(card)}`;
         // A card with nothing to disclose must not advertise the toggle.
-        this.collapsedHint = ` ${presentation.summary(card)}${this.expandable ? ' — ctrl+o to expand' : ''}`;
-        this.expandedBody = new UserMessageComponent(styleAttachMarkdownSource(cardDisclosure(presentation, card.body)), attachMarkdownTheme());
+        this.collapsedHint = `${this.summaryText}${this.expandable ? ' — ctrl+o to expand' : ''}`;
+        this.expandedBody = new UserMessageComponent(styleAttachMarkdownSource(cardDisclosure(presentation, card)), attachMarkdownTheme());
     }
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded) {
         if (this.expandable)
             this.expanded = expanded;
     }
+    /** Paint the [label] tag in the accent color and the rest dim. Truncate
+     *  BEFORE painting so the ANSI wrappers never inflate the measured width — an
+     *  over-wide line aborts the whole TUI render. */
+    headerRow(w, hint) {
+        const labelW = visibleWidth(this.labelTag);
+        if (labelW >= w)
+            return this.label(truncateToWidth(this.labelTag, w, '…'));
+        return this.label(this.labelTag) + this.dim(truncateToWidth(hint, w - labelW, '…'));
+    }
     render(width) {
         const w = width > 0 ? width : 80;
-        if (!this.expanded) {
-            // Paint the [label] tag in the accent color and the rest dim, so the label
-            // reads distinctly in BOTH states. Truncate BEFORE painting so the ANSI
-            // wrappers never inflate the measured width (an over-wide line aborts the
-            // whole TUI render).
-            const labelW = visibleWidth(this.labelTag);
-            if (labelW >= w)
-                return ['', this.label(truncateToWidth(this.labelTag, w, '…')), ''];
-            return ['', this.label(this.labelTag) + this.dim(truncateToWidth(this.collapsedHint, w - labelW, '…')), ''];
-        }
+        // The header stays in BOTH states: expanding replaces the card's body, not
+        // its identity, and consecutive disclosed cards are otherwise a run of
+        // unattributed bubbles.
+        if (!this.expanded)
+            return ['', this.headerRow(w, this.collapsedHint), ''];
         const lines = this.expandedBody.render(w);
         if (lines.at(-1) !== '')
             lines.push('');
-        return lines;
+        return ['', this.headerRow(w, this.summaryText), ...lines];
     }
     invalidate() {
         /* stateless — nothing to clear */

package/dist/clients/attach/session/context.d.ts

@@ -22,6 +22,9 @@ export interface AttachContainers {
     readonly queued: Container;
     /** Native pickers (/model etc.), inline directly under the editor. */
     readonly pickerPanel: Container;
+    /** The inline ticket page (chrome/ticket-panel.ts), below the recap header
+     *  — the expanded form of the strip's notification row. */
+    readonly ticketPanel: Container;
     /** Extension widgets placed `belowEditor`. */
     readonly belowWidgets: Container;
     /** The status line. */

package/dist/clients/attach/session/frame.d.ts

@@ -12,6 +12,10 @@ export declare function cropAroundCursor(lines: readonly string[], alloc: number
 export interface ViewerFrameParts {
     /** Rendered above the transcript; 0 rows when empty. */
     header: Component;
+    /** The inline ticket page, directly beneath the header — the expanded form
+     *  of the strip's notification row. It grows downward to whatever the page
+     *  needs, squeezing the transcript to zero before the cockpit gives a row. */
+    ticket: Component;
     viewport: TranscriptViewport;
     /** The bottom slots, in VISUAL order, tagged with their allocation identity
      * so the allocator can apply the §2.1 priority table. */

package/dist/clients/attach/session/frame.js

@@ -112,17 +112,21 @@ export class ViewerFrame {
         let headerLines = this.parts.header.render(width).slice(0, HEADER_MAX_ROWS);
         if (rows - bottomLines.length - headerLines.length < MIN_TRANSCRIPT_ROWS)
             headerLines = [];
-        const viewportRows = Math.max(0, rows - headerLines.length - bottomLines.length);
+        // The ticket page takes every row the header and cockpit left, before the
+        // transcript sees any — a tall page legitimately drives the viewport to 0.
+        const ticketAll = this.parts.ticket.render(width);
+        const ticketLines = ticketAll.slice(0, Math.max(0, rows - headerLines.length - bottomLines.length));
+        const viewportRows = Math.max(0, rows - headerLines.length - ticketLines.length - bottomLines.length);
         this.viewportRows = viewportRows;
         let viewportLines = this.parts.viewport.renderSlice(width, viewportRows);
-        let frame = [...headerLines, ...viewportLines, ...bottomLines];
+        let frame = [...headerLines, ...ticketLines, ...viewportLines, ...bottomLines];
         // A misbehaving viewport is repaired in its own region only: transcript
         // padding goes directly beneath the header, while excess drops from its top.
         // The cockpit, including the editor's marker row, is never sliced here.
         if (frame.length !== rows) {
             reportInvariant(`frame rendered ${frame.length} rows; expected ${rows}`);
             viewportLines = fitTranscript(viewportLines, viewportRows);
-            frame = [...headerLines, ...viewportLines, ...bottomLines];
+            frame = [...headerLines, ...ticketLines, ...viewportLines, ...bottomLines];
         }
         if (frame.length !== rows)
             reportInvariant(`frame correction rendered ${frame.length} rows; expected ${rows}`);
@@ -152,6 +156,7 @@ export class ViewerFrame {
     }
     invalidate() {
         this.parts.header.invalidate();
+        this.parts.ticket.invalidate();
         for (const { component } of this.parts.bottom)
             component.invalidate();
         this.parts.viewport.invalidate();

package/dist/clients/attach/session/keys.d.ts

@@ -14,6 +14,11 @@ export interface KeyHooks {
     /** Transcript search's chance at a chunk; true when it consumed it. It owns
      *  typed characters while editing a query, so it runs ahead of the editor. */
     searchHandleKey: (data: string) => boolean;
+    /** The inline ticket panel: while open it consumes EVERY chunk — pages
+     *  carry text inputs — so it runs ahead of search, scroll, and the lists. */
+    panelHandleKey: (data: string) => boolean;
+    /** The inbox strip's chance at a chunk; true when it consumed it. */
+    stripHandleKey: (data: string) => boolean;
     /** The roster's chance at a chunk; true when it consumed it. */
     rosterHandleKey: (data: string) => boolean;
     setNotice: (message: string) => void;
@@ -22,6 +27,8 @@ export interface KeyHooks {
     toggleHelp: () => void;
     /** Toggle the mounted inbox surface. */
     toggleInbox: () => void;
+    /** Enter or leave the top-of-pane pending-request strip. */
+    toggleInboxStrip: () => void;
     cycleModelLadder: (direction: 'forward' | 'backward') => void;
     inspectLoadedCommand: () => void;
     /** The file-review chord — open the transcript-file picker + review surface. */

package/dist/clients/attach/session/keys.js

@@ -33,6 +33,7 @@ export function installGlobalKeys(ctx, hooks) {
         'crtr.attach.graph.toggle': hooks.toggleGraph,
         'crtr.attach.help.toggle': hooks.toggleHelp,
         'crtr.attach.inbox.toggle': hooks.toggleInbox,
+        'crtr.attach.inbox-strip': hooks.toggleInboxStrip,
         // A plain broker frame, so this works locally and remotely alike; the broker gates observers on controller role.
         'crtr.attach.model-ladder.next': () => hooks.cycleModelLadder('forward'),
         'crtr.attach.model-ladder.previous': () => hooks.cycleModelLadder('backward'),
@@ -57,12 +58,18 @@ export function installGlobalKeys(ctx, hooks) {
         }
         if (hooks.hasExclusiveSurface())
             return undefined;
+        if (hooks.panelHandleKey(data))
+            return { consume: true };
         if (hooks.searchHandleKey(data))
             return { consume: true };
         // Let focused pickers and overlays retain their native page navigation.
         if (editor.focused && dispatchAttachViewportBinding(hooks.bindings(), data, hooks.viewportActions()))
             return { consume: true };
         // Inline subagent scroll+swap: once the editor hands off at its ↓ boundary, ↑/↓ move over the manager/report roster and Enter dives into a node. An inactive roster never intercepts editor input.
+        // The inbox strip while it holds the highlight — ahead of the roster, whose
+        // rows the same arrows would otherwise move.
+        if (hooks.stripHandleKey(data))
+            return { consume: true };
         if (hooks.rosterHandleKey(data))
             return { consume: true };
         return dispatchAttachBinding(hooks.bindings(), data, actions) ? { consume: true } : undefined;

package/dist/clients/attach/session/layout.js

@@ -6,9 +6,10 @@
 // reader asking "where does this line get painted?" needs only this one.
 //
 // The render order is asserted in ONE place (`ViewerFrame`'s bottom list).
-// Top to bottom: pinned recap header · virtualized chat · cockpit padding · fixed activity ·
-// above-editor extension widgets · queued · editor · picker panel · below-editor
-// extension widgets · roster · search bar · status bar. The frame owns the pane rectangle,
+// Top to bottom: pinned recap header · inline ticket page · virtualized chat ·
+// cockpit padding · fixed activity · above-editor extension widgets · queued ·
+// editor · picker panel · below-editor extension widgets · roster · search bar ·
+// status bar. The frame owns the pane rectangle,
 // so every region remains on screen and none can enter terminal scrollback.
 import { Container, Spacer } from '@earendil-works/pi-tui';
 import { getSelectListTheme } from '@earendil-works/pi-coding-agent';
@@ -25,6 +26,7 @@ export function createLayout(procTerminal, tui, chat, activity, pal, km, viewpor
         reports: new Container(),
         queued: new Container(),
         pickerPanel: new Container(),
+        ticketPanel: new Container(),
         belowWidgets: new Container(),
         footer: new Container(),
     };
@@ -34,6 +36,7 @@ export function createLayout(procTerminal, tui, chat, activity, pal, km, viewpor
     const editor = new TitledEditor(tui, editorTheme, km, { paddingX: 1 });
     const frame = new ViewerFrame(procTerminal, {
         header: containers.header,
+        ticket: containers.ticketPanel,
         viewport,
         bottom: [
             { slot: 'cockpitPadding', component: new Spacer(1) },

package/dist/clients/attach/session/pane-focus.d.ts

@@ -0,0 +1,8 @@
+import type { TitledEditor } from '../input/titled-editor.js';
+export interface PaneFocus {
+    /** Recompute the editor's cursor style from pane focus + the holders. */
+    sync(): void;
+    /** Report real tmux-pane focus (DECSET 1004). Repaints the editor cursor. */
+    setPaneFocused(focused: boolean): void;
+}
+export declare function createPaneFocus(editor: TitledEditor, holders: ReadonlyArray<() => boolean>): PaneFocus;

package/dist/clients/attach/session/pane-focus.js

@@ -0,0 +1,42 @@
+// session/pane-focus.ts — the ONE owner of the editor's hollow-cursor state.
+//
+// The cursor is dimmed whenever the tmux pane is blurred OR any chrome list
+// (the below-editor roster, the top-of-pane inbox strip) holds the highlight:
+// while a list is scrolled the editor is "away", so it must read exactly like
+// an unfocused pane. Both lists report their active state through `holders`;
+// they call `sync()` whenever that state may have flipped, and the viewer
+// feeds real tmux focus (DECSET 1004) in through `setPaneFocused`.
+import { execFileSync } from 'node:child_process';
+/** Seed pane focus from the pane's REAL active state, not an unconditional
+ *  `true`. tmux only emits DECSET 1004 focus events on a TRANSITION, so a viewer
+ *  spawned into a non-active pane (a `split -d` beside another node — the
+ *  auto-viewer for a background child) starts unfocused and NEVER receives a
+ *  FOCUS_OUT, leaving a solid cursor drawn until the user swaps in and back out.
+ *  Query `#{pane_active}` for our own pane once at startup so an unfocused split
+ *  renders hollow immediately; default true when not in tmux or the query fails. */
+function initialPaneActive() {
+    const pane = process.env['TMUX_PANE'];
+    if (pane === undefined || pane === '')
+        return true;
+    try {
+        const out = execFileSync('tmux', ['display-message', '-p', '-t', pane, '#{pane_active}'], { encoding: 'utf8' }).trim();
+        return out !== '0';
+    }
+    catch {
+        return true;
+    }
+}
+export function createPaneFocus(editor, holders) {
+    let paneFocused = initialPaneActive();
+    const sync = () => {
+        editor.paneFocused = paneFocused && !holders.some((holds) => holds());
+    };
+    sync();
+    return {
+        sync,
+        setPaneFocused: (focused) => {
+            paneFocused = focused;
+            sync();
+        },
+    };
+}