@sigrun/tui 0.1.0 → 0.1.1

package/dist/blocks/width.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Terminal width for block rendering (UI-blocks U2 Task 1): the width
+ * classes (spec §12.1), the `s`/`m`/`l` token scale (spec §5.2), and the
+ * clamp/pad helpers every block renderer funnels through.
+ *
+ * The display-width measure is pi-tui's `visibleWidth` (grapheme-aware,
+ * wcwidth-style, ANSI-safe) — re-exported here so block code has ONE
+ * width import site and the Review-Focus-2 invariant ("every rendered
+ * line's display width ≤ the pane") is enforced in one place:
+ * {@link truncate}.
+ */
+import type { Size } from "@sigrun/shared/blocks";
+/** The container width classes (spec §12.1, TUI column). */
+export type WidthClass = "compact" | "regular" | "wide";
+/** The compact/regular/wide boundary: cells (compact < 80 ≤ regular < 140 ≤ wide). */
+export declare function widthClassOf(cells: number): WidthClass;
+/** Width tokens in cells (spec §5.2: the TUI maps s/m/l to 30/45/60). */
+export declare const SIZE_CELLS: Readonly<Record<Size, number>>;
+/**
+ * Clamp one rendered line to `width` cells with an ellipsis (Review
+ * Focus 2): ANSI-aware, wide-character-aware, never a mid-sequence cut.
+ * Empty lines pass through.
+ */
+export declare function truncate(line: string, width: number): string;
+/** Pad a line to `width` cells by its DISPLAY width (for column joins). */
+export declare function pad(line: string, width: number): string;
+/**
+ * Fit a run of source lines into `width` cells: short runs stay one
+ * line (truncated); longer word-wraps fold at spaces, each folded line
+ * truncated. Used for plain-text values (markdown wraps itself).
+ */
+export declare function wrapPlain(text: string, width: number): string[];

package/dist/blocks/width.js

@@ -0,0 +1,70 @@
+/**
+ * Terminal width for block rendering (UI-blocks U2 Task 1): the width
+ * classes (spec §12.1), the `s`/`m`/`l` token scale (spec §5.2), and the
+ * clamp/pad helpers every block renderer funnels through.
+ *
+ * The display-width measure is pi-tui's `visibleWidth` (grapheme-aware,
+ * wcwidth-style, ANSI-safe) — re-exported here so block code has ONE
+ * width import site and the Review-Focus-2 invariant ("every rendered
+ * line's display width ≤ the pane") is enforced in one place:
+ * {@link truncate}.
+ */
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+/** The compact/regular/wide boundary: cells (compact < 80 ≤ regular < 140 ≤ wide). */
+export function widthClassOf(cells) {
+    if (cells < 80)
+        return "compact";
+    if (cells < 140)
+        return "regular";
+    return "wide";
+}
+/** Width tokens in cells (spec §5.2: the TUI maps s/m/l to 30/45/60). */
+export const SIZE_CELLS = {
+    s: 30,
+    m: 45,
+    l: 60,
+};
+/**
+ * Clamp one rendered line to `width` cells with an ellipsis (Review
+ * Focus 2): ANSI-aware, wide-character-aware, never a mid-sequence cut.
+ * Empty lines pass through.
+ */
+export function truncate(line, width) {
+    if (line === "")
+        return "";
+    return truncateToWidth(line, width, "…");
+}
+/** Pad a line to `width` cells by its DISPLAY width (for column joins). */
+export function pad(line, width) {
+    const rest = width - visibleWidth(line);
+    return rest > 0 ? line + " ".repeat(rest) : line;
+}
+/**
+ * Fit a run of source lines into `width` cells: short runs stay one
+ * line (truncated); longer word-wraps fold at spaces, each folded line
+ * truncated. Used for plain-text values (markdown wraps itself).
+ */
+export function wrapPlain(text, width) {
+    if (width <= 0)
+        return [];
+    const words = text.split(/\s+/).filter((w) => w !== "");
+    if (words.length === 0)
+        return [""];
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+        if (current === "") {
+            current = word;
+        }
+        else if (visibleWidth(current) + 1 + visibleWidth(word) <= width) {
+            current += ` ${word}`;
+        }
+        else {
+            lines.push(current);
+            current = word;
+        }
+    }
+    if (current !== "")
+        lines.push(current);
+    return lines.map((line) => truncate(line, width));
+}

package/dist/keymaps/emacs.js

@@ -34,6 +34,14 @@ const BINDINGS = [
     { keys: "C-o", action: "answer interaction" },
     { keys: "C-l", action: "redraw" },
     { keys: "C-h", action: "key reference" },
+    { keys: "M-m", action: "pick up (block surface)" },
+    { keys: "enter", action: "drop (block surface)" },
+    { keys: "C-g", action: "cancel move (block surface)" },
+    { keys: "space", action: "select (block surface)" },
+    { keys: ".", action: "action menu (block surface)" },
+    { keys: "x", action: "check (block surface)" },
+    { keys: "[ / ]", action: "previous / next range (calendar)" },
+    { keys: "t", action: "today (calendar)" },
 ];
 /** Match `data` against any reserved chord (they always pass). */
 function isReserved(data) {
@@ -71,6 +79,30 @@ export function createEmacsKeymap() {
         }
         return undefined;
     };
+    /** Block-surface keys (spec §12.4; emacs picks up with M-m). C-g is
+     *  the cancel key — it cancels a move on a surface BEFORE the global
+     *  C-g (cancel-run / focus composer) below sees it. */
+    const surface = (data) => {
+        if (data === "\x1bm")
+            return { type: "blocks.pickUp" }; // M-m
+        if (matchesKey(data, Key.enter) || data === "\r")
+            return { type: "blocks.drop" };
+        if (data === "\x07")
+            return { type: "blocks.cancelMove" }; // C-g
+        if (data === " ")
+            return { type: "blocks.select" };
+        if (data === ".")
+            return { type: "blocks.actionMenu" };
+        if (data === "x")
+            return { type: "blocks.check" };
+        if (data === "[")
+            return { type: "blocks.rangePrev" };
+        if (data === "]")
+            return { type: "blocks.rangeNext" };
+        if (data === "t")
+            return { type: "blocks.today" };
+        return undefined;
+    };
     return {
         name: "emacs",
         modeLabel: () => undefined,
@@ -89,6 +121,13 @@ export function createEmacsKeymap() {
             const chorded = chord(data);
             if (chorded !== undefined)
                 return chorded;
+            // A block surface owns the §12.4 keys (its C-g is cancel-move,
+            // which must win over the global C-g cancel-run).
+            if (ctx.focus === "surface") {
+                const surfaceResult = surface(data);
+                if (surfaceResult !== undefined)
+                    return surfaceResult;
+            }
             if (data === "\x1bx")
                 return { type: "picker", kind: "command" };
             if (data === "\x13")

package/dist/keymaps/standard.js

@@ -35,6 +35,14 @@ const BINDINGS = [
     { keys: "/", action: "search transcript" },
     { keys: "n / N", action: "next / previous match" },
     { keys: "?", action: "help" },
+    { keys: "m", action: "pick up (block surface)" },
+    { keys: "enter", action: "drop (block surface)" },
+    { keys: "esc", action: "cancel move (block surface)" },
+    { keys: "space", action: "select (block surface)" },
+    { keys: ".", action: "action menu (block surface)" },
+    { keys: "x", action: "check (block surface)" },
+    { keys: "[ / ]", action: "previous / next range (calendar)" },
+    { keys: "t", action: "today (calendar)" },
 ];
 /** Match `data` against any reserved chord (they always pass). */
 function isReserved(data) {
@@ -64,7 +72,11 @@ export function createStandardKeymap() {
                 return "pass";
             if (ctx.busy)
                 return { type: "cancel-run" };
-            return { type: "focus", target: "composer" };
+            // A block surface owns Esc: it cancels a pick-up
+            // (blocks.cancelMove) — the surface branch below handles it.
+            if (ctx.focus !== "surface")
+                return { type: "focus", target: "composer" };
+            return undefined;
         }
         return undefined;
     };
@@ -99,6 +111,27 @@ export function createStandardKeymap() {
             return { type: "help" };
         return undefined;
     };
+    const surface = (data) => {
+        // Block-surface keys (spec §12.4): routed ONLY here; the app
+        // forwards the action to the focused block component.
+        if (data === "m")
+            return { type: "blocks.pickUp" };
+        if (matchesKey(data, Key.enter))
+            return { type: "blocks.drop" };
+        if (data === " ")
+            return { type: "blocks.select" };
+        if (data === ".")
+            return { type: "blocks.actionMenu" };
+        if (data === "x")
+            return { type: "blocks.check" };
+        if (data === "[")
+            return { type: "blocks.rangePrev" };
+        if (data === "]")
+            return { type: "blocks.rangeNext" };
+        if (data === "t")
+            return { type: "blocks.today" };
+        return undefined;
+    };
     return {
         name: "standard",
         modeLabel: () => undefined,
@@ -113,6 +146,17 @@ export function createStandardKeymap() {
             const globalResult = global(data, ctx);
             if (globalResult !== undefined)
                 return globalResult;
+            if (ctx.focus === "surface") {
+                const surfaceResult = surface(data);
+                if (surfaceResult !== undefined)
+                    return surfaceResult;
+                // Esc on a surface: cancel a pick-up (§12.4). The host treats
+                // a cancel with NO pick-up in flight as focus-composer (the
+                // emacs C-g ordering rule, mirrored here).
+                if (matchesKey(data, Key.escape))
+                    return { type: "blocks.cancelMove" };
+                return "pass";
+            }
             if (ctx.focus !== "composer") {
                 const navResult = outsideComposer(data);
                 if (navResult !== undefined)

package/dist/keymaps/vim.js

@@ -51,6 +51,14 @@ const BINDINGS = [
     { keys: "ctrl+c", action: "abort run (busy)" },
     { keys: "g?", action: "key reference" },
     { keys: "ZZ / :q", action: "quit" },
+    { keys: "m", action: "pick up (block surface)" },
+    { keys: "enter", action: "drop (block surface)" },
+    { keys: "esc", action: "cancel move (block surface)" },
+    { keys: "space", action: "select (block surface)" },
+    { keys: ".", action: "action menu (block surface)" },
+    { keys: "x", action: "check (block surface)" },
+    { keys: "[ / ]", action: "previous / next range (calendar)" },
+    { keys: "t", action: "today (calendar)" },
 ];
 function isReserved(data) {
     return RESERVED_KEYS.some((id) => matchesKey(data, id));
@@ -117,11 +125,40 @@ export function createVimKeymap(options) {
             return { type: "answer-interaction" };
         return "pass";
     };
+    /** Block-surface keys (spec §12.4): NORMAL mode over a `surface`
+     *  focus. The surface wins over transcript/list bindings for the
+     *  shared keys (o/x/etc). */
+    const surfaceNormal = (data) => {
+        if (data === "m")
+            return { type: "blocks.pickUp" };
+        if (matchesKey(data, Key.enter))
+            return { type: "blocks.drop" };
+        if (matchesKey(data, Key.escape))
+            return { type: "blocks.cancelMove" };
+        if (data === " ")
+            return { type: "blocks.select" };
+        if (data === ".")
+            return { type: "blocks.actionMenu" };
+        if (data === "x")
+            return { type: "blocks.check" };
+        if (data === "[")
+            return { type: "blocks.rangePrev" };
+        if (data === "]")
+            return { type: "blocks.rangeNext" };
+        if (data === "t")
+            return { type: "blocks.today" };
+        return undefined;
+    };
     const normal = (data, ctx) => {
         // ctrl+b / ctrl+f are NOT bound in vim normal — reserved chords pass.
         const chorded = chord(data);
         if (chorded !== undefined)
             return chorded;
+        if (ctx.focus === "surface") {
+            const surfaceResult = surfaceNormal(data);
+            if (surfaceResult !== undefined)
+                return surfaceResult;
+        }
         if (data === "y")
             return { type: "copy" }; // yy is two copies — same action
         if (data === "j")

package/dist/launch.js

@@ -204,6 +204,9 @@ export async function launchTuiShell(options) {
     ]);
     tui.setLayoutRoot(root);
     await app.refresh();
+    // U3 Task 5: the sidebar's Views group loads with the conversations
+    // (one /v1/extensions GET per boot; failures fail quiet).
+    void app.sidebar.refreshViews().catch(() => { });
     // The host events subscription (core hardening W3 Task 4, spec §7.4):
     // ONE stream per process replaces the poll timers — `conversation.*`
     // refetches the sidebar listing, `interaction.*` kicks the prompter,
@@ -224,8 +227,18 @@ export async function launchTuiShell(options) {
             else if (event.type === "ambient.changed") {
                 app.ambient.kick(event.conversationId);
             }
+            else if (event.type === "surface.changed") {
+                // U3 Task 5: fan the surface event out to the open
+                // view's transport (the hub matches slug+id+k).
+                app.dispatchSurfaceChanged(event);
+            }
         },
         onError: (message) => app.pane.showNotice(message),
+        // U3 Task 5 (§7.3): the hello frame's streamId is the watcher
+        // entry's stream — open ext-view transports send it as
+        // X-Sigrun-Stream. A reconnect's new id re-registers on the
+        // next fetch.
+        onHello: (streamId) => app.setEventsStreamId(streamId),
     }, {
         baseUrl: options.baseUrl,
         ...(options.user === undefined ? {} : { user: options.user }),

package/dist/sse.d.ts

@@ -92,6 +92,14 @@ export declare function watchConversation(conversationId: number, handlers: Watc
 export interface EventsHandlers {
     /** A host event arrived (already JSON-parsed). */
     readonly onEvent: (event: HostEventWire) => void;
+    /**
+     * The hello frame's streamId (UI-blocks U3 Task 4, spec §7.3's W3
+     * amendment): fired on EVERY (re)connect — a reconnect's hello
+     * carries a NEW id, and the channel re-fetches every visible surface
+     * with it (re-registering the watcher entries). Surface fetches send
+     * the current id as `X-Sigrun-Stream`.
+     */
+    readonly onHello?: (streamId: string) => void;
     /** A failure: malformed frame (stays open) or transport error (reconnects). */
     readonly onError?: (message: string) => void;
     /** The underlying connection (re)opened with an OK response. */

package/dist/sse.js

@@ -326,6 +326,33 @@ export function watchEvents(handlers, options) {
         const parser = createFrameParser((frame) => {
             if (closed)
                 return;
+            // The hello frame (U3 Task 4) is connection-local: it names
+            // THIS stream for the watcher registry — surface fetches send
+            // the id as `X-Sigrun-Stream`; a NEW id (reconnect) re-fires
+            // so the channel re-registers. It never reaches onEvent (the
+            // launch wiring's switch would ignore it anyway — event types
+            // are an open set). Parsed loosely: the hello payload carries
+            // `streamId`, not a `type` member.
+            if (frame.event === "hello") {
+                let parsed;
+                try {
+                    parsed = JSON.parse(frame.data);
+                }
+                catch {
+                    handlers.onError?.("malformed hello frame (not JSON)");
+                    return;
+                }
+                // SAFETY: the JSON.parse output is unknown; the read below
+                // narrows `streamId` by typeof before use.
+                const streamId = parsed.streamId;
+                if (typeof streamId === "string") {
+                    handlers.onHello?.(streamId);
+                }
+                else {
+                    handlers.onError?.("malformed hello frame (no streamId)");
+                }
+                return;
+            }
             const event = parseEvent(frame.data);
             if (event === undefined) {
                 handlers.onError?.(`malformed ${frame.event === "" ? "message" : frame.event} frame (not an event object)`);

package/dist/theme.d.ts

@@ -18,8 +18,8 @@
  */
 import { type TerminalColorMode } from "@earendil-works/pi-tui";
 import { type AccentName, type ModeName, type PaletteName, type PaletteTokens } from "@sigrun/shared/themes";
-/** A palette token, or the accent colour. */
-export type TuiToken = keyof PaletteTokens | "accent";
+/** A palette token, the accent colour, or a state colour (warn/bad). */
+export type TuiToken = keyof PaletteTokens | "accent" | "warn" | "bad";
 /**
  * Terminal styling surface: token-named fg/bg plus the plain attribute
  * helpers. `fg`/`bg` return string wrappers so call sites compose

package/dist/theme.js

@@ -43,10 +43,22 @@ function rgbToHex(r, g, b) {
     const two = (n) => n.toString(16).padStart(2, "0");
     return `#${two(r)}${two(g)}${two(b)}`;
 }
+/**
+ * The state colours (warnings + errors), defined per mode like the
+ * webui's `--warn`/`--danger` (webui/src/app.css — they are NOT palette
+ * members in either channel). The TUI's tone table (blocks/tones.ts)
+ * paints `warn`/`bad` tones with them.
+ */
+const STATE_COLORS = {
+    warn: { dark: "#d9a35a", light: "#8a6116" },
+    bad: { dark: "#e0707a", light: "#b3363f" },
+};
 /** Resolve a token to a parseable colour for the palette+mode. */
-function resolveToken(tokens, accentHex, token) {
+function resolveToken(tokens, accentHex, mode, token) {
     if (token === "accent")
         return accentHex;
+    if (token === "warn" || token === "bad")
+        return STATE_COLORS[token][mode];
     const value = tokens[token];
     // `code` is the rgba overlay chip; composite over the mode's bg.
     if (value.startsWith("rgba"))
@@ -75,8 +87,10 @@ export function createTuiTheme(options) {
         "ok",
         "code",
         "accent",
+        "warn",
+        "bad",
     ]) {
-        const color = parseColor(resolveToken(tokens, accentHex, token));
+        const color = parseColor(resolveToken(tokens, accentHex, options.mode, token));
         fgSequences.set(token, foregroundAnsi(color, mode));
         bgSequences.set(token, backgroundAnsi(color, mode));
     }

package/dist/ui/app.d.ts

@@ -48,6 +48,7 @@
  */
 import { Editor, type Component, type TUI } from "@earendil-works/pi-tui";
 import type { SigrunClient } from "../api.js";
+import type { JsonObject } from "@sigrun/shared/blocks";
 import { type Unwatch, type WatchHandlers, type WatchOptions } from "../sse.js";
 import type { TuiTheme } from "../theme.js";
 import type { Action, ActionHost, Focus } from "../actions.js";
@@ -91,6 +92,41 @@ export declare class TuiApp implements Component, ActionHost {
     constructor(client: SigrunClient, options: TuiAppOptions);
     /** The active conversation id (undefined before the first refresh). */
     get activeConversationId(): number | undefined;
+    /** The launcher's hello hook (U3 Task 5): the stream id feeds
+     *  future openExtView transports; an OPEN view's handle gets the
+     *  new id at once (its next fetch re-registers the watcher entry —
+     *  spec §7.3's reconnect rule; the webui twin remounts instead). */
+    setEventsStreamId(streamId: string): void;
+    /** The open extension view's identity (undefined = the conversation
+     *  pane is the main content). */
+    get extView(): {
+        readonly slug: string;
+        readonly id: string;
+    } | undefined;
+    /**
+     * Open an extension VIEW in the main pane (U3 Task 5, spec §7.1):
+     * the sidebar's view selection swaps the pane's content to the
+     * surface's transport. The block renderer is U2's; the app holds
+     * the transport + identity here so U2's mount is one prop pass.
+     */
+    openExtView(slug: string, id: string, params?: JsonObject): Promise<void>;
+    /**
+     * Close the open extension view (the Esc/back idiom): the pane
+     * returns to the conversation AND the surface's fetches stop — no
+     * cadence, no keepalive for a surface nobody is looking at (spec
+     *  §7.3's stop-when-hidden rule; U2's cadence timer consults this).
+     *  Returns true when a view was open (the key was consumed).
+     */
+    closeExtView(): boolean;
+    /** The app-level surface.changed dispatch (the launcher's
+     *  `watchEvents` onEvent routes events here). */
+    dispatchSurfaceChanged(event: {
+        slug: string;
+        id: string;
+        k: string;
+        rev: number;
+        treeRev: number;
+    }): void;
     /** The focused region (the action layer's routing state). */
     get focus(): Focus;
     /** A modal overlay (picker/search) owns the keys. */

package/dist/ui/app.js

@@ -48,6 +48,7 @@
  */
 import { Editor, HStack, Key, matchesKey, VStack, } from "@earendil-works/pi-tui";
 import { SigrunApiError } from "../api.js";
+import { ExtSurfaceHub, surfaceKeyHash, transportKey, } from "../blocks/ext-transport.js";
 import { watchConversation } from "../sse.js";
 import { spawnSync } from "node:child_process";
 import { editInVim, resolveVimEditor } from "../editor-launch.js";
@@ -79,6 +80,14 @@ function plainEditorTheme() {
 }
 export class TuiApp {
     #client;
+    /** The extension-surface transport hub (U3 Task 5): one per app —
+     *  `openExtView`'s transport subscribes through it; the launcher
+     *  dispatches `surface.changed` events into it. */
+    #extHub = new ExtSurfaceHub();
+    /** The open extension view (the main pane's surface state). The
+     *  HANDLE (not the bare transport): a reconnect's new stream id
+     *  lands via setStreamId without re-creating the transport. */
+    #extView;
     #watch;
     #watchOptions;
     /** The sidebar (the app mounts it; tests drive it). */
@@ -158,6 +167,12 @@ export class TuiApp {
             if (selection === "new") {
                 void this.createAndSelect();
             }
+            else if (typeof selection === "object") {
+                // An extension VIEW (U3 Task 5): open it in the main pane.
+                void this.openExtView(selection.view.slug, selection.view.id).catch((error) => {
+                    this.pane.showError(describeCommandError("open view", error));
+                });
+            }
             else {
                 // Caught at the call site (fix wave F1): selectConversation
                 // keeps propagating for boot's fail-loud refresh, so the
@@ -175,6 +190,69 @@ export class TuiApp {
     get activeConversationId() {
         return this.#activeId;
     }
+    /** The current /v1/events stream id (the hello frame's payload);
+     *  the ext-view transports send it as X-Sigrun-Stream. */
+    #eventsStreamId;
+    /** The launcher's hello hook (U3 Task 5): the stream id feeds
+     *  future openExtView transports; an OPEN view's handle gets the
+     *  new id at once (its next fetch re-registers the watcher entry —
+     *  spec §7.3's reconnect rule; the webui twin remounts instead). */
+    setEventsStreamId(streamId) {
+        this.#eventsStreamId = streamId;
+        this.#extView?.handle.setStreamId(streamId);
+    }
+    /** The open extension view's identity (undefined = the conversation
+     *  pane is the main content). */
+    get extView() {
+        return this.#extView === undefined
+            ? undefined
+            : { slug: this.#extView.slug, id: this.#extView.id };
+    }
+    /**
+     * Open an extension VIEW in the main pane (U3 Task 5, spec §7.1):
+     * the sidebar's view selection swaps the pane's content to the
+     * surface's transport. The block renderer is U2's; the app holds
+     * the transport + identity here so U2's mount is one prop pass.
+     */
+    async openExtView(slug, id, params) {
+        const key = transportKey({ slug, id, baseUrl: this.#watchOptions.baseUrl, ...(params === undefined ? {} : { params }) });
+        const handle = this.#extHub.attach({
+            slug,
+            id,
+            ...(params === undefined ? {} : { params }),
+            baseUrl: this.#watchOptions.baseUrl,
+            ...(this.#watchOptions.user === undefined
+                ? {}
+                : { user: this.#watchOptions.user }),
+            ...(this.#watchOptions.token === undefined
+                ? {}
+                : { token: this.#watchOptions.token }),
+            ...(this.#eventsStreamId === undefined
+                ? {}
+                : { streamId: this.#eventsStreamId }),
+        }, surfaceKeyHash(slug, id, key));
+        this.#extView = { slug, id, handle };
+        this.#tui.requestRender();
+    }
+    /**
+     * Close the open extension view (the Esc/back idiom): the pane
+     * returns to the conversation AND the surface's fetches stop — no
+     * cadence, no keepalive for a surface nobody is looking at (spec
+     *  §7.3's stop-when-hidden rule; U2's cadence timer consults this).
+     *  Returns true when a view was open (the key was consumed).
+     */
+    closeExtView() {
+        if (this.#extView === undefined)
+            return false;
+        this.#extView = undefined;
+        this.#tui.requestRender();
+        return true;
+    }
+    /** The app-level surface.changed dispatch (the launcher's
+     *  `watchEvents` onEvent routes events here). */
+    dispatchSurfaceChanged(event) {
+        this.#extHub.dispatch(event);
+    }
     /** The focused region (the action layer's routing state). */
     get focus() {
         return this.#focus;
@@ -447,6 +525,12 @@ export class TuiApp {
             this.#abortActive();
             return true;
         }
+        // Esc closes an open extension view — back to the
+        // conversation pane; the surface's fetches stop (the keepalive
+        // stops with the view, spec §7.3's stop-when-hidden).
+        if (matchesKey(data, Key.escape) && this.#extView !== undefined) {
+            return this.closeExtView();
+        }
         return false;
     }
     /**

package/dist/ui/interactions.js

@@ -42,6 +42,7 @@
  * `[error]` line).
  */
 import { Key, matchesKey } from "@earendil-works/pi-tui";
+import { diffLines } from "../blocks/diff.js";
 import { describeCommandError } from "./composer.js";
 /** The answer-mode option pick keys: digits 1-9. */
 const DIGIT = /^[1-9]$/;
@@ -281,13 +282,7 @@ export class InteractionPrompter {
                 lines.push(line);
         }
         if (body?.diff !== undefined) {
-            lines.push(body.diff.path === undefined
-                ? "[diff]"
-                : `[diff] ${body.diff.path}`);
-            for (const line of body.diff.before.split("\n"))
-                lines.push(`- ${line}`);
-            for (const line of body.diff.after.split("\n"))
-                lines.push(`+ ${line}`);
+            lines.push(...diffLines(body.diff));
         }
         for (const [index, option] of options.entries()) {
             const marker = this.#answerMode && multi

package/dist/ui/sidebar.d.ts

@@ -24,8 +24,15 @@
 import { type Component } from "@earendil-works/pi-tui";
 import { type TuiTheme } from "../theme.js";
 import type { SigrunClient } from "../api.js";
-/** The sidebar selection: a conversation id, or the `+ new` action. */
-export type SidebarSelection = number | "new";
+/** The sidebar selection: a conversation id, the `+ new` action, or an
+ *  extension VIEW (UI-blocks U3 Task 5 — the app opens it in the main
+ *  pane). */
+export type SidebarSelection = number | "new" | {
+    readonly view: {
+        readonly slug: string;
+        readonly id: string;
+    };
+};
 /** One display row: a conversation, or the trailing `+ New` action. */
 interface SidebarRow {
     /** The conversation id; -1 for the `+ New conversation` action row. */
@@ -62,6 +69,22 @@ export declare class Sidebar implements Component {
      * conversation when it still exists.
      */
     refresh(): Promise<void>;
+    /**
+     * The extension views (U3 Task 5): refetch `GET /v1/extensions` and
+     * rebuild the VIEWS group (one row per declared view surface, in
+     * declaration order, status "ok" only). Panels live in the side pane,
+     * not here. Failures keep the last good list (a flaky server must
+     * never blank the sidebar).
+     */
+    refreshViews(): Promise<void>;
+    /** The extension view rows (the app's openExtView reads them). */
+    get views(): readonly {
+        slug: string;
+        id: string;
+        title: string;
+    }[];
+    /** Select the Nth extension view (the action layer's seam). */
+    confirmView(index: number): void;
     /** Mark the active conversation (accent fg + bold); pass `undefined` to clear. */
     setActive(id: number | undefined): void;
     /** Move the cursor by `delta` rows, clamped to the list. */