@crouton-kit/crouter 0.3.61 → 0.3.62

package/dist/clients/attach/canvas-panels.d.ts

@@ -1,3 +1,4 @@
+import { type CanvasSource } from '../../core/canvas/source.js';
 import type { AttachPalette } from './config-load.js';
 export interface CanvasPanelLines {
     /** Above-editor manager line(s) — empty for a root node (no manager). */
@@ -5,8 +6,7 @@ export interface CanvasPanelLines {
     /** Below-editor report row(s) + self's trailing ⚑ asks line — empty when none. */
     reports: string[];
 }
-/** Build the BASE panel line stacks for `nodeId` from canvas.db (ported verbatim
- *  from canvas-nav.ts renderBase). `asks` is the per-node pending-ask map the
- *  caller polls; pass `{}` to omit the ⚑ badges. `palette` (the live theme)
+/** Build the BASE panel line stacks for `nodeId`. `asks` is the per-node
+ *  pending-ask map the caller polls; pass `{}` to omit the ⚑ badges. `palette`
  *  drives the headers + dim cells; omit it and the panels render uncolored. */
-export declare function buildCanvasPanelLines(nodeId: string, asks: Record<string, number>, palette?: AttachPalette): CanvasPanelLines;
+export declare function buildCanvasPanelLines(nodeId: string, asks: Record<string, number>, palette?: AttachPalette, source?: CanvasSource): Promise<CanvasPanelLines>;

package/dist/clients/attach/canvas-panels.js

@@ -1,18 +1,19 @@
 // canvas-panels.ts — the subscribed-node panel for `crtr surface attach` (Unit Q).
 //
-// Native reimplementation of canvas-nav.ts's BASE chrome (renderBase), reading
-// the subscription graph DIRECTLY from canvas.db via the shared nav-model layer
-// (no pi extension host, no broker frame). Produces the two line stacks the
-// viewer paints into Containers around the editor:
+// Native implementation of canvas-nav.ts's BASE chrome (renderBase), reading
+// through the CanvasSource seam so the viewer chrome and graph overlay share the
+// same canvas read authority. Produces the two line stacks the viewer paints
+// into Containers around the editor:
 //   managers  → ABOVE the editor: this node's manager (its first subscriber).
 //   reports   → BELOW the editor: this node's live reports (active|idle
 //               subscriptions), plus a trailing ⚑ line for self's own asks.
 //
 // Pure: given a node id + the per-node ask map it returns ANSI strings; the
-// caller owns the Containers and the refresh trigger. beginFrame() memoizes the
-// canvas.db reads for this one build pass (mirrors canvas-nav's per-frame cache),
-// so a whole panel rebuild is a single fan-out of disk/db reads.
-import { beginFrame, cNode, managerOf, liveReports, climbRoot, computeSubtreeActivity, navLabel, nodeGlyph, truncate, tokensCell, cycleBadge, childBadge, liveBelowBadge, askBadge, activityCell, YELLOW, RESET, } from '../../core/canvas/nav-model.js';
+// caller owns the Containers and the refresh trigger. beginFrame() clears the
+// nav-model telemetry cache for this one build pass so token/activity cells are
+// read fresh for every chrome frame.
+import { beginFrame, navLabel, nodeGlyph, truncate, tokensCell, cycleBadge, askBadge, activityCell, YELLOW, RESET, DIM, GREEN, } from '../../core/canvas/nav-model.js';
+import { localCanvasSource } from '../../core/canvas/source.js';
 /** Column widths for the aligned panel rows (visible columns). name is sized to
  *  the widest label across BOTH panels (capped); kind is wide enough for the
  *  longest persona kind (`orchestrator` = 12) so real kinds never truncate;
@@ -28,49 +29,119 @@ function nameCell(s, w) {
 function padStartVisible(s, w) {
     return s.length >= w ? s.slice(0, w) : ' '.repeat(w - s.length) + s;
 }
-/** Build the BASE panel line stacks for `nodeId` from canvas.db (ported verbatim
- *  from canvas-nav.ts renderBase). `asks` is the per-node pending-ask map the
- *  caller polls; pass `{}` to omit the ⚑ badges. `palette` (the live theme)
+/** Build the BASE panel line stacks for `nodeId`. `asks` is the per-node
+ *  pending-ask map the caller polls; pass `{}` to omit the ⚑ badges. `palette`
  *  drives the headers + dim cells; omit it and the panels render uncolored. */
-export function buildCanvasPanelLines(nodeId, asks, palette) {
-    // Fresh snapshot: drop the previous build's memoized reads so this pass sees
-    // current disk+db state, then read-once within it.
+export async function buildCanvasPanelLines(nodeId, asks, palette, source = localCanvasSource) {
     beginFrame();
-    // Styling: theme-driven when a palette is passed, plain otherwise (so the
-    // panels still build for a non-attach caller / a test).
+    const nodes = new Map();
+    const children = new Map();
+    const managersOf = new Map();
+    const node = (id) => {
+        const hit = nodes.get(id);
+        if (hit !== undefined)
+            return hit;
+        const p = source.getNode(id).catch(() => null);
+        nodes.set(id, p);
+        return p;
+    };
+    const convoChildIds = (id) => {
+        const hit = children.get(id);
+        if (hit !== undefined)
+            return hit;
+        const p = (async () => {
+            const refs = await source.subscriptionsOf(id).catch(() => []);
+            const out = [];
+            for (const ref of refs) {
+                if ((await node(ref.node_id))?.kind !== 'human')
+                    out.push(ref.node_id);
+            }
+            return out;
+        })();
+        children.set(id, p);
+        return p;
+    };
+    const managerOf = (id) => {
+        const hit = managersOf.get(id);
+        if (hit !== undefined)
+            return hit;
+        const p = source.subscribersOf(id).then((refs) => refs[0]?.node_id).catch(() => undefined);
+        managersOf.set(id, p);
+        return p;
+    };
+    const liveReports = async (id) => {
+        const out = [];
+        for (const cid of await convoChildIds(id)) {
+            const st = (await node(cid))?.status;
+            if (st === 'active' || st === 'idle')
+                out.push(cid);
+        }
+        return out;
+    };
+    const climbRoot = async (self) => {
+        let cur = self;
+        const seen = new Set([cur]);
+        for (;;) {
+            const mgr = await managerOf(cur);
+            if (mgr === undefined || seen.has(mgr))
+                break;
+            seen.add(mgr);
+            cur = mgr;
+        }
+        return cur;
+    };
+    const activeBelow = new Map();
+    const computeActivity = async (root) => {
+        const seen = new Set();
+        const visit = async (id) => {
+            const selfActive = (await node(id))?.status === 'active';
+            if (seen.has(id))
+                return selfActive ? 1 : 0;
+            seen.add(id);
+            let below = 0;
+            for (const c of await convoChildIds(id))
+                below += await visit(c);
+            activeBelow.set(id, below);
+            return below + (selfActive ? 1 : 0);
+        };
+        await visit(root);
+    };
+    const childBadgeFor = async (n) => {
+        if (n === null || n.mode !== 'orchestrator')
+            return '';
+        const m = (await convoChildIds(n.node_id)).length;
+        return m > 0 ? ` ${DIM}⤳${m}${RESET}` : '';
+    };
+    const liveBelowBadgeFor = (n) => {
+        if (n === null || n.status === 'active')
+            return '';
+        const count = activeBelow.get(n.node_id) ?? 0;
+        return count > 0 ? ` ${GREEN}⇣${count}${RESET}` : '';
+    };
     const muted = palette?.muted ?? ((s) => s);
     const faint = palette?.faint ?? ((s) => s);
-    // One subtree-activity pass (rooted at the ancestry root) feeds the ⇣N
-    // live-work-below badge on both the manager line and every report row.
-    const activity = computeSubtreeActivity(climbRoot(nodeId), nodeId);
-    // One shared name-column width across BOTH panels so the grids line up.
-    const mgr = managerOf(nodeId);
-    const live = liveReports(nodeId);
+    await computeActivity(await climbRoot(nodeId));
+    const mgr = await managerOf(nodeId);
+    const live = await liveReports(nodeId);
     const gridIds = [...(mgr !== undefined ? [mgr] : []), ...live];
+    const gridNodes = await Promise.all(gridIds.map((id) => node(id)));
     const nameW = gridIds.length > 0
-        ? Math.min(NAME_CAP, Math.max(...gridIds.map((id) => navLabel(cNode(id), id).length)))
+        ? Math.min(NAME_CAP, Math.max(...gridIds.map((id, i) => navLabel(gridNodes[i] ?? null, id).length)))
         : NAME_CAP;
-    // A node row laid out on the shared grid: glyph · name · kind · tokens · badges.
-    const row = (id) => {
-        const n = cNode(id);
+    const row = async (id) => {
+        const n = await node(id);
         const name = nameCell(navLabel(n, id), nameW);
         const kind = faint(nameCell(n?.kind ?? '', KIND_W));
         const tokens = muted(padStartVisible(tokensCell(id), TOK_W));
-        const badges = `${cycleBadge(n)}${childBadge(n)}${liveBelowBadge(n, activity.activeBelow)}${askBadge(id, asks)}${activityCell(id, n)}`;
+        const badges = `${cycleBadge(n)}${await childBadgeFor(n)}${liveBelowBadgeFor(n)}${askBadge(id, asks)}${activityCell(id, n)}`;
         return truncate(` ${nodeGlyph(n)} ${name}  ${kind} ${tokens}${badges}`);
     };
-    // --- managers panel (↑) ---
     const managers = [];
-    if (mgr !== undefined) {
-        managers.push(row(mgr));
-    }
-    // --- reports panel (↓) ---
+    if (mgr !== undefined)
+        managers.push(await row(mgr));
     const reports = [];
-    if (live.length > 0) {
-        for (const id of live)
-            reports.push(row(id));
-    }
-    // Self's own pending asks (no self row in BASE) → a trailing inline line.
+    for (const id of live)
+        reports.push(await row(id));
     const selfAsks = asks[nodeId] ?? 0;
     if (selfAsks > 0)
         reports.push(` ${YELLOW}⚑ ${selfAsks} pending${RESET}`);

package/dist/clients/attach/chat-view.js

@@ -25,6 +25,7 @@ import { AssistantMessageComponent, BashExecutionComponent, BranchSummaryMessage
 import { ContextMessageComponent } from './context-message.js';
 import { CRTR_OUTPUT_CUSTOM_TYPE, CrtrOutputMessageComponent, createCrtrBashToolDefinition, } from './crtr-output-render.js';
 import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE } from '../../core/runtime/session-cycles.js';
+import { SITUATIONAL_CONTEXT_CUSTOM_TYPE } from '../../core/runtime/situational-context.js';
 import { transformMessageMermaid } from './mermaid-render.js';
 /** customType stamped on the injected `<crtr-context>` bearings block (mirrors
  *  CONTEXT_INTRO_CUSTOM_TYPE in canvas-context-intro.ts — kept as a local literal
@@ -444,6 +445,16 @@ export class ChatView {
                         (s) => this.spinnerStyle(this.labelStyle(s))));
                         break;
                     }
+                    // The hidden ambient `<situational-context>` update (canvas-inbox-watcher's
+                    // ~non-birth wake path). Rendered collapsed exactly like `crtr-context`
+                    // (same component, distinct label) so an existing-node ambient update is
+                    // never more prominent in the transcript than the bearings block it rides
+                    // alongside on fresh birth — the LLM sees the full content either way; only
+                    // the viewer's display treatment differs.
+                    if (message.customType === SITUATIONAL_CONTEXT_CUSTOM_TYPE) {
+                        this.append(new ContextMessageComponent(this.userMessageText(message), this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)), 'situational context', ' ambient context update — ctrl+o to expand'));
+                        break;
+                    }
                     if (message.customType === CRTR_OUTPUT_CUSTOM_TYPE) {
                         this.append(new CrtrOutputMessageComponent(this.userMessageText(message), this.toolOutputExpanded, this.crtrOutputTheme()));
                         break;

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

@@ -3,8 +3,10 @@ export declare class ContextMessageComponent implements Component {
     private readonly body;
     private readonly dim;
     private readonly label;
+    private readonly labelText;
+    private readonly collapsedHint;
     private expanded;
-    constructor(body: string, expanded: boolean, dim: (s: string) => string, label: (s: string) => string);
+    constructor(body: string, expanded: boolean, dim: (s: string) => string, label: (s: string) => string, labelText?: string, collapsedHint?: string);
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded: boolean): void;
     render(width: number): string[];

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

@@ -1,15 +1,20 @@
-// context-message.ts — the viewer's foldable renderer for the `<crtr-context>`
-// bearings block (a `crtr-context` custom message). The broker runs the
-// canvas-context-intro extension, so the VIEWER has no message renderer for it
-// and would otherwise show the full block always. This reimplements the
-// extension's `renderContextMessage` natively (src/pi-extensions/
-// canvas-context-intro.ts): collapsed → one dim line; expanded (Ctrl+O) →
-// label + full wrapped body. It implements `setExpanded`, so the Ctrl+O
-// tool-output toggle (ChatView.toggleToolsExpanded → isExpandable) folds it
-// alongside tool output.
+// context-message.ts — the viewer's foldable renderer for hidden-context custom
+// messages: the `<crtr-context>` bearings block (customType `crtr-context`) and
+// the ambient `<situational-context>` update (customType
+// `crtr-situational-context`). Both are broker-injected (canvas-context-intro,
+// canvas-inbox-watcher), so the VIEWER has no message renderer for either and
+// would otherwise show the full block always. This reimplements the bearings
+// renderer natively (src/pi-extensions/canvas-context-intro.ts:
+// `renderContextMessage`) and reuses the same collapsed/expand shape for
+// situational context so both render consistently: collapsed → one dim line;
+// expanded (Ctrl+O) → label + full wrapped body. It implements `setExpanded`,
+// so the Ctrl+O tool-output toggle (ChatView.toggleToolsExpanded →
+// isExpandable) folds it alongside tool output.
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
-/** The label shown in both states. Mirrors the extension's customType stamp. */
+/** Default label/hint for the `crtr-context` bearings block. Mirrors the
+ *  extension's customType stamp. */
 const LABEL = 'crtr context';
+const COLLAPSED_HINT = ' orienting bearings — ctrl+o to expand';
 /** Char-based wrap that never emits an over-width line (pi-tui hard-crashes on
  *  one). Visible-width aware so wide glyphs in the bearings tree count right. */
 function wrapLine(line, width) {
@@ -34,11 +39,15 @@ export class ContextMessageComponent {
     body;
     dim;
     label;
+    labelText;
+    collapsedHint;
     expanded;
-    constructor(body, expanded, dim, label) {
+    constructor(body, expanded, dim, label, labelText = LABEL, collapsedHint = COLLAPSED_HINT) {
         this.body = body;
         this.dim = dim;
         this.label = label;
+        this.labelText = labelText;
+        this.collapsedHint = collapsedHint;
         this.expanded = expanded;
     }
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
@@ -48,18 +57,18 @@ export class ContextMessageComponent {
     render(width) {
         const w = width > 0 ? width : 80;
         if (!this.expanded) {
-            // Paint the [crtr context] label 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 labelText = `[${LABEL}]`;
-            const rest = ' orienting bearings — ctrl+o to expand';
-            const labelW = visibleWidth(labelText);
+            // 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 labelTag = `[${this.labelText}]`;
+            const rest = this.collapsedHint;
+            const labelW = visibleWidth(labelTag);
             if (labelW >= w)
-                return [this.label(truncateToWidth(labelText, w, '…'))];
-            return [this.label(labelText) + this.dim(truncateToWidth(rest, w - labelW, '…'))];
+                return [this.label(truncateToWidth(labelTag, w, '…'))];
+            return [this.label(labelTag) + this.dim(truncateToWidth(rest, w - labelW, '…'))];
         }
-        const lines = [this.label(truncateToWidth(`[${LABEL}]`, w, '…')), ''];
+        const lines = [this.label(truncateToWidth(`[${this.labelText}]`, w, '…')), ''];
         for (const raw of this.body.split('\n')) {
             for (const seg of wrapLine(raw, w))
                 lines.push(seg);

package/dist/clients/attach/graph-overlay.d.ts

@@ -1,10 +1,12 @@
 import { type Component, type TUI } from '@earendil-works/pi-tui';
+import { type CanvasSource } from '../../core/canvas/source.js';
 import type { AttachPalette } from './config-load.js';
 export declare class GraphOverlay implements Component {
     private readonly tui;
     private readonly self;
     private readonly getAsks;
     private readonly palette;
+    private readonly source;
     private handle;
     /** Manual fold OVERRIDES (h collapses → userCollapsed, l expands → userExpanded);
      *  both override the default activity-driven policy and survive open/close. */
@@ -17,7 +19,9 @@ export declare class GraphOverlay implements Component {
     private scrollTop;
     /** Transient y/n confirm gate (kill). */
     private pendingConfirm;
-    constructor(tui: TUI, self: string, getAsks: () => Record<string, number>, palette: AttachPalette);
+    private snapshot;
+    private snapshotSeq;
+    constructor(tui: TUI, self: string, getAsks: () => Record<string, number>, palette: AttachPalette, source?: CanvasSource);
     isOpen(): boolean;
     open(): void;
     close(): void;
@@ -25,6 +29,8 @@ export declare class GraphOverlay implements Component {
     /** Repaint if shown (the low-rate ask poll calls this). */
     refresh(): void;
     invalidate(): void;
+    private buildSnapshot;
+    private renderSnapshotRow;
     render(width: number): string[];
     /** A top/bottom border row: `<lc>─ <label> ────<rc>`, frame in the theme border
      *  color, the label keeping its own styling. The label is visible-truncated to
@@ -38,6 +44,7 @@ export declare class GraphOverlay implements Component {
      *  `id` has no viewer yet a fresh one splits beside this pane; if it already has
      *  one, that viewer is navigated in place (this pane is left as-is). We pass
      *  TMUX_PANE explicitly so the anchor is THIS pane even if env resolution differs. */
+    private logAsyncFailure;
     private focusTarget;
     private shellCrtr;
 }