@miadi/chronicle-tui 0.9.1 → 0.10.0

package/README.md

@@ -36,8 +36,8 @@ On Termux, install with `--ignore-scripts`. Node 22 or later.
 | `v` | hold a Miadi review in the episode (writer token) |
 | `i` | the episode's inquiries and, when you may write, the shelf: Enter attaches one, a dry run first, `y` confirms |
 | `t` | the episode's companion seat (Mia) through tide: the plan first, `y` runs it only when it would act, `A` asks again archiving the running session |
-| `T` | this machine's tmux sessions, the episode in focus's first. Inside tmux, Enter opens one beside the chronicle; outside, it hands the terminal over until you detach |
-| `F`, `X` | with a session beside: focus it (prefix+arrow comes back); detach it (the session goes on). Inside the split, `prefix prefix d` detaches too; its border says so |
+| `T` | this machine's tmux sessions, the episode in focus's first. Inside tmux: Enter shows one on the right, `+` adds one below it (two at most), `e` goes to its episode; the list stays open. Outside tmux, Enter hands the terminal over until you detach |
+| `F`, `X` | with sessions on the right: focus them in turn (Alt+s in one comes back); detach them all (they go on). Inside a split, `prefix prefix d` detaches that one; its border says so |
 | `L` | relate episodes: `L` marks the one in focus, move to the other, `L` again, say why (relates to or continues from, one way or both). Esc forgets the mark |
 | `?` | all keys · `q` quits from the main view (in a window it closes the window) · `Q` quits from any window, except while typing the filter · Ctrl+C quits too |
 
@@ -99,30 +99,40 @@ miadi-chronicle --url https://miadi.tail3b11eb.ts.net
 Write actions declare `effect: "write"` and are offered only when the app said
 it would record them.
 
-## A session beside the chronicle
+## Sessions on the right
 
 Run the browser inside tmux and `T` lists the sessions on this machine, each
 with the episode it works in (the vessel its pane is in, or the number its
-name carries), the sessions of the episode in focus first. Enter on one:
-
-- **inside tmux**, tmux splits the browser's window and shows that session in
-  the split, live, as a client of its own (`env -u TMUX tmux attach`). You type
-  in it directly. The prefix once moves between the panes; the session's own
-  tmux keys take the prefix twice. The browser jumps to the session's episode
-  and keeps it current: its files are read again every 5 s, and a file changed
-  in the last 15 minutes is marked ●, so you see what the agent is touching.
-  The header shows `⇆ <session> · <command> · <idle>`, and the split's border
-  says which session it is and how to come back. `F` focuses the split. To
-  detach it, press `X` in the chronicle, or `prefix prefix d` inside the split
-  (the prefix once goes to your tmux, twice to the session's client). Either
-  way the session goes on, the border goes back as it was, and the chronicle
-  returns to where you were before the session took it to its episode.
-- **outside tmux**, the browser steps aside and runs `tmux attach` in this
-  terminal; `prefix d` brings you back to the same screen.
-
-While you type in it, the split is that session's most recent client, so its
-window takes the split's size, as with any tmux client. The browser never types
-into a session; only your keys reach it, and tmux never inherits a token.
+name carries), the sessions of the episode in focus first. The list stays open
+while you work with it:
+
+- **Enter** shows the session on the right of the browser, live, as a client of
+  its own (`env -u TMUX tmux attach`). Whatever was on the right is detached
+  first, so Enter on the next session swaps it in.
+- **`+`** adds the session below the one on the right, up to two (`MAX_BESIDE`).
+- **`e`** closes the list and goes to the session's episode.
+- **`F`** focuses the sessions on the right in turn; you type in them directly.
+  **Alt+s** in a split brings the focus back to the browser, where the list
+  is. The key is bound in tmux only while a split is open, acts only in a
+  split's pane (anywhere else it passes the key on), is left alone when you
+  bound it to something already, and is removed with the last split. Set
+  `MIADI_CHRONICLE_RETURN_KEY` to another tmux key, or `none`. `prefix ;`
+  (tmux's last pane) comes back too.
+- **`X`** detaches every session on the right. `prefix prefix d` inside a split
+  detaches that one (the prefix once goes to your tmux, twice to the session's
+  client). Either way the sessions go on, and with the last split the window's
+  border goes back as it was.
+
+Each split's border names its session and says how to come back. The header
+shows `⇆ <session> · <command> · <idle>` for each. The episodes of the
+sessions on the right are read every 5 s, and a file changed in the last 15
+minutes is marked ●, so you see what an agent is touching.
+
+While you type in a split it is that session's most recent client, so the
+session's window takes the split's size, as with any tmux client, until its
+own client is used again. The browser never types into a session; only your
+keys reach it, and tmux never inherits a token. Outside tmux, Enter runs
+`tmux attach` in this terminal and `prefix d` brings you back.
 
 ## Inquiries and the companion seat
 

package/dist/App.d.ts

@@ -29,5 +29,7 @@ export interface AppProps {
     /** Environment keys `--env` loaded: an opener never inherits them. */
     withheld?: readonly string[];
 }
+/** How many sessions the right side holds, one above the other. */
+export declare const MAX_BESIDE = 2;
 export declare function App(props: AppProps): React.JSX.Element;
 //# sourceMappingURL=App.d.ts.map

package/dist/App.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../src/App.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAiD,MAAM,OAAO,CAAA;AAIrE,OAAO,EAML,KAAK,eAAe,EAIrB,MAAM,cAAc,CAAA;AAuFrB,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,gDAAgD;IAChD,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;IACpC,kFAAkF;IAClF,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,sEAAsE;IACtE,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC7B;AAkID,wBAAgB,GAAG,CAAC,KAAK,EAAE,QAAQ,qBA60DlC"}
+{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../src/App.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAiD,MAAM,OAAO,CAAA;AAIrE,OAAO,EAML,KAAK,eAAe,EAIrB,MAAM,cAAc,CAAA;AA2FrB,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,gDAAgD;IAChD,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;IACpC,kFAAkF;IAClF,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,sEAAsE;IACtE,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC7B;AAUD,mEAAmE;AACnE,eAAO,MAAM,UAAU,IAAI,CAAA;AAkI3B,wBAAgB,GAAG,CAAC,KAAK,EAAE,QAAQ,qBAm4DlC"}

package/dist/App.js

@@ -21,10 +21,12 @@ import { BOARD_LABELS, ROOM_LABELS, answeredMessage, checkAnswer, filterBoard, l
 import { CEREMONY_TYPES, DIARY_PHASES, DIRECTIONS, ENTRY_TYPES, PHASE_LABELS, ceremonyHeadline, ceremonyLines, circleEntries, closeCeremony, mayWitness, openCeremony, readCeremony, readCircle, scrollTo, speak, splitLearnings, typeLabel, whenOf, witness, writeDiary, } from "./circles.js";
 import { ISSUE_REF, weaveInquiry, wovenMessage, previewLines, readInquiries } from "./inquiries.js";
 import { companionLines, companionPlan, planActs, ranMessage, runCompanion } from "./tide.js";
-import { attachHere, closePane, focusPane, idleFor, insideTmux, listSessions, openBeside, markSplit, unmarkSplit, DETACH_HINT, orderSessions, paneAlive, tmuxEnv, } from "./sessions.js";
+import { attachHere, closePane, focusPane, idleFor, insideTmux, listSessions, openBeside, markWindow, labelSplit, unmarkSplit, returnKey, keyLabel, bindReturnKey, unbindReturnKey, orderSessions, paneAlive, tmuxEnv, } from "./sessions.js";
 import { VISITOR, wheelDoors, loadChronicle, loadDetail, loadText, openUrl, qrLines, search, visibleRows, } from "./data.js";
 import { ageOf, clamp, fileView, filterRows, formatDate, screenLineOf, windowOf, wrapSegments, } from "./model.js";
 import { clean, cleanLine, link } from "./text.js";
+/** How many sessions the right side holds, one above the other. */
+export const MAX_BESIDE = 2;
 const DIRECTION_MARK = { east: "E", south: "S", west: "W", north: "N" };
 const DIRECTION_COLOR = { east: "yellow", south: "red", west: "blue", north: "white" };
 function Segments({ segments, selectedRef }) {
@@ -676,32 +678,40 @@ export function App(props) {
         const d = derive();
         return o.sessions && d.s.chronicle ? orderSessions(o.sessions, d.visible, d.s.chronicle.root, o.episode, o.own) : [];
     };
-    /**
-     * The split is gone, by `X` or by a detach inside it: the window's border goes
-     * back as it was, and the chronicle returns to where it was before the session
-     * took it to its episode, unless the person moved on since.
-     */
+    const env = () => tmuxEnv(process.env, withheld);
+    /** Every split is gone: the window's border goes back as it was, and the return key is unbound unless another split uses it. */
     const endBeside = async (message) => {
         const beside = ui.current.beside;
         if (!beside)
             return;
-        const d = derive();
-        const stillThere = beside.jumped && d.s.view === "files" && d.currentRow?.name === beside.episode && d.s.history.length > 0;
-        set({ beside: undefined });
-        if (stillThere)
-            back();
-        set({ status: message });
+        set({ beside: undefined, status: message });
         if (beside.mark)
-            await unmarkSplit(beside.mark, tmuxEnv(process.env, withheld));
+            await unmarkSplit(beside.mark, env());
+        if (beside.returnKey)
+            await unbindReturnKey(beside.returnKey, env());
     };
+    /** `X`: detach every session on the right; they go on. */
     const closeBeside = async () => {
         const beside = ui.current.beside;
         if (!beside)
             return;
-        await closePane(beside.paneId, tmuxEnv(process.env, withheld));
-        await endBeside(`Detached ${beside.session}; it goes on.`);
+        for (const slot of beside.slots)
+            await closePane(slot.paneId, env());
+        const names = beside.slots.map((slot) => slot.session).join(" and ");
+        await endBeside(`Detached ${names}; ${beside.slots.length > 1 ? "they go" : "it goes"} on.`);
     };
-    const openSession = async (row) => {
+    /** The sessions list shows what is on the right: read tmux again after a change. */
+    const refreshSessionsList = async () => {
+        const sessions = await listSessions(env());
+        const stack = ui.current.overlays.map((entry) => (entry.overlay.type === "sessions" ? { id: entry.id, overlay: { ...entry.overlay, sessions } } : entry));
+        set({ overlays: stack, status: ui.current.status });
+    };
+    /**
+     * Show a session on the right. `below` adds it under the ones there (up to
+     * MAX_BESIDE); otherwise it takes the right side alone, detaching what was
+     * there. The sessions list stays open, so the next one is a key away.
+     */
+    const openSession = async (row, below = false) => {
         const name = row.session.name;
         if (row.own)
             return set({ status: `${name} is this browser's own session.` });
@@ -709,58 +719,92 @@ export function App(props) {
             // Outside tmux the terminal itself is handed over, and comes back on detach.
             let outcome = { ok: false };
             await suspendTerminal(() => {
-                outcome = attachHere(name, tmuxEnv(process.env, withheld));
+                outcome = attachHere(name, env());
             });
             return set({ status: outcome.ok ? `Back from ${name}.` : cleanLine(outcome.message ?? `Could not attach ${name}.`) });
         }
-        if (ui.current.beside)
-            await closeBeside();
+        const current = ui.current.beside;
+        if (current?.slots.some((slot) => slot.session === name))
+            return set({ status: `${name} is already on the right.` });
+        if (below && current && current.slots.length >= MAX_BESIDE) {
+            return set({ status: `${MAX_BESIDE} sessions are on the right already: Enter shows ${name} alone, X detaches them.` });
+        }
+        const adding = below && current && current.slots.length > 0;
         try {
-            const env = tmuxEnv(process.env, withheld);
-            const paneId = await openBeside(name, { env });
-            // The border says which session it is and how to come back; a window that refuses it still works.
-            const mark = await markSplit(paneId, name, env).catch(() => undefined);
-            // The chronicle side shows the episode the session works in.
-            const jumped = Boolean(row.episode && derive().rowByName(row.episode));
-            set({ beside: { session: name, paneId, episode: row.episode, info: row.session, mark, jumped }, overlays: [] });
-            if (jumped)
-                jumpTo(row.episode);
-            set({ status: `${name} is beside you · F focuses it, prefix+arrow comes back · X detaches it here, ${DETACH_HINT.replace(": ", " in it: ")}.` });
+            let slots = current?.slots ?? [];
+            if (!adding) {
+                for (const slot of slots)
+                    await closePane(slot.paneId, env());
+                slots = [];
+            }
+            const paneId = adding ? await openBeside(name, { below: true, pane: slots[slots.length - 1].paneId, env: env() }) : await openBeside(name, { env: env() });
+            // The border names the session and says how to come back; a window that refuses it still works.
+            const mark = current?.mark ?? (await markWindow(paneId, env()).catch(() => undefined));
+            const wanted = returnKey();
+            const key = current?.returnKey ?? (wanted && (await bindReturnKey(wanted, env()).catch(() => false)) ? wanted : undefined);
+            await labelSplit(paneId, name, { returnTo: process.env.TMUX_PANE, returnKey: key, env: env() }).catch(() => { });
+            const slot = { session: name, paneId, episode: row.episode, info: row.session };
+            set({ beside: { slots: [...slots, slot], mark, returnKey: key, focus: 0 } });
+            const back = key ? `${keyLabel(key)} in it comes back here` : "prefix ; comes back here";
+            set({ status: `${name} is on the right${adding ? ", below" : ""} · F focuses it, ${back} · X detaches ${adding ? "both" : "it"}.` });
+            await refreshSessionsList();
         }
         catch (error) {
-            set({ beside: undefined, status: cleanLine(`Could not open ${name}: ${error.message}`) });
+            set({ status: cleanLine(`Could not open ${name}: ${error.message}`) });
         }
     };
-    // While a session is beside the chronicle: every second, is the split still there (a detach inside it closes it);
-    // every five, what the session runs and what changed in its episode.
+    /** `F`: focus the sessions on the right in turn. */
+    const focusBeside = () => {
+        const beside = ui.current.beside;
+        if (!beside?.slots.length)
+            return;
+        const slot = beside.slots[beside.focus % beside.slots.length];
+        set({ beside: { ...beside, focus: beside.focus + 1 } });
+        focusPane(slot.paneId, env()).catch((error) => set({ status: cleanLine(error.message) }));
+    };
+    // While sessions are on the right: every second, which splits are still there (a detach inside one closes it);
+    // every five, what each session runs and what changed in its episode.
     const besideTick = useRef(0);
     useEffect(() => {
         const timer = setInterval(async () => {
             const beside = ui.current.beside;
             if (!beside)
                 return;
-            const env = tmuxEnv(process.env, withheld);
-            if (!(await paneAlive(beside.paneId, env))) {
-                if (ui.current.beside?.paneId === beside.paneId)
-                    await endBeside(`Detached from ${beside.session}; back in the chronicle. It goes on.`);
+            const alive = await Promise.all(beside.slots.map((slot) => paneAlive(slot.paneId, env())));
+            if (ui.current.beside !== beside)
+                return;
+            const gone = beside.slots.filter((_, index) => !alive[index]);
+            if (gone.length) {
+                const left = beside.slots.filter((_, index) => alive[index]);
+                const names = gone.map((slot) => slot.session).join(" and ");
+                if (left.length === 0)
+                    await endBeside(`Detached from ${names}; back in the chronicle. ${gone.length > 1 ? "They go" : "It goes"} on.`);
+                else
+                    set({ beside: { ...beside, slots: left }, status: `Detached from ${names}; ${left.map((slot) => slot.session).join(" and ")} stays on the right.` });
+                void refreshSessionsList();
                 return;
             }
             if (++besideTick.current % 5 !== 0)
                 return;
-            const info = (await listSessions(env)).find((session) => session.name === beside.session);
-            if (ui.current.beside?.paneId !== beside.paneId)
+            const sessions = await listSessions(env());
+            if (ui.current.beside !== beside)
                 return;
-            if (beside.episode)
-                details.current.delete(`${ui.current.access.mayWrite}:${beside.episode}`);
-            set({ beside: { ...beside, info: info ?? beside.info }, status: ui.current.status });
+            for (const slot of beside.slots)
+                if (slot.episode)
+                    details.current.delete(`${ui.current.access.mayWrite}:${slot.episode}`);
+            const slots = beside.slots.map((slot) => ({ ...slot, info: sessions.find((session) => session.name === slot.session) ?? slot.info }));
+            set({ beside: { ...beside, slots }, status: ui.current.status });
         }, 1_000);
         return () => {
             clearInterval(timer);
             const beside = ui.current.beside;
             if (beside) {
-                void closePane(beside.paneId, tmuxEnv(process.env, withheld));
+                for (const slot of beside.slots)
+                    void closePane(slot.paneId, env());
                 if (beside.mark)
-                    void unmarkSplit(beside.mark, tmuxEnv(process.env, withheld));
+                    void unmarkSplit(beside.mark, env());
+                if (beside.returnKey)
+                    void unbindReturnKey(beside.returnKey, env());
             }
         };
     }, []);
@@ -901,8 +945,21 @@ export function App(props) {
                 if (key.upArrow || input === "k")
                     return updateTop({ ...top, selected: clamp(top.selected - 1, rows.length) });
                 const row = rows[clamp(top.selected, rows.length)];
+                // Enter: this session alone on the right. +: below the one there. The list stays, for the next one.
                 if (row && (key.return || input === "l" || key.rightArrow))
                     return void openSession(row);
+                if (row && input === "+")
+                    return void openSession(row, true);
+                if (input === "X")
+                    return void closeBeside();
+                if (input === "F")
+                    return focusBeside();
+                if (row && input === "e") {
+                    if (!row.episode || !derive().rowByName(row.episode))
+                        return set({ status: `${row.session.name} works in no episode you can see.` });
+                    set({ overlays: [] });
+                    return jumpTo(row.episode);
+                }
                 return;
             }
             if (top.type === "inquiries") {
@@ -1126,10 +1183,8 @@ export function App(props) {
             return forward();
         if (key.escape && s.relateFrom)
             return set({ relateFrom: undefined, status: "No longer relating." });
-        if (s.beside && input === "F") {
-            focusPane(s.beside.paneId, tmuxEnv(process.env, withheld)).catch((error) => set({ status: cleanLine(error.message) }));
-            return;
-        }
+        if (s.beside && input === "F")
+            return focusBeside();
         if (s.beside && input === "X")
             return void closeBeside();
         if (key.escape || key.leftArrow || input === "h" || key.backspace)
@@ -1277,8 +1332,13 @@ export function App(props) {
             return box("green", _jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, wrap: "truncate-end", children: ["Sessions", " ", _jsxs(Text, { color: "gray", children: ["\u00B7 ", insideTmux() ? "Enter opens one beside the chronicle" : "Enter hands this terminal to it; prefix d comes back"] })] }), !top.sessions && !top.error ? _jsx(Text, { color: "gray", children: "Asking tmux\u2026" }) : null, top.error ? _jsx(Text, { color: "red", wrap: "wrap", children: cleanLine(top.error) }) : null, rows.length && focusLabel ? (_jsxs(Text, { color: "gray", wrap: "truncate-end", children: [rows.some((row) => row.here) ? `${focusLabel} first` : `none works in ${focusLabel}`, " \u00B7 \u25CF has a client \u00B7 \u25CB has none"] })) : null, listWindow.items.map((row, index) => {
                         const isSelected = listWindow.start + index === clamp(top.selected, rows.length);
                         const where = row.episode ? episodeLabel(row.episode) : "";
-                        return (_jsxs(Text, { wrap: "truncate-end", inverse: isSelected, children: [_jsx(Text, { color: row.session.attached ? "green" : "gray", children: row.session.attached ? "●" : "○" }), " ", _jsx(Text, { bold: row.here, children: cleanLine(row.session.name) }), _jsx(Text, { color: "gray", children: [where, cleanLine(row.session.command), idleFor(row.session.activity, now), row.own ? "this browser" : ""].filter(Boolean).map((part) => ` · ${part}`).join("") })] }, row.session.name));
-                    }), _jsx(Text, { color: "gray", wrap: "truncate-end", children: "\u2191\u2193 \u00B7 \u23CE open \u00B7 Esc" })] }));
+                        const slot = s.beside?.slots.findIndex((candidate) => candidate.session === row.session.name) ?? -1;
+                        return (_jsxs(Text, { wrap: "truncate-end", inverse: isSelected, children: [slot >= 0 ? _jsx(Text, { color: "cyan", children: slot === 0 ? "⇆ " : "⇣ " }) : null, _jsx(Text, { color: row.session.attached ? "green" : "gray", children: row.session.attached ? "●" : "○" }), " ", _jsx(Text, { bold: row.here, children: cleanLine(row.session.name) }), _jsx(Text, { color: "gray", children: [where, cleanLine(row.session.command), idleFor(row.session.activity, now), row.own ? "this browser" : ""].filter(Boolean).map((part) => ` · ${part}`).join("") })] }, row.session.name));
+                    }), _jsx(Text, { color: "gray", wrap: "truncate-end", children: insideTmux()
+                            ? compact
+                                ? `⏎ right · + below · e · ${s.beside ? "F X · " : ""}Esc`
+                                : `↑↓ · ⏎ on the right · + below it (up to ${MAX_BESIDE}) · e its episode${s.beside ? " · F focus · X detach" : ""} · Esc`
+                            : "↑↓ · ⏎ open · e its episode · Esc" })] }));
         }
         if (top.type === "inquiries") {
             const view = top.view;
@@ -1380,7 +1440,7 @@ export function App(props) {
         if (s.overlays.length)
             return compact ? "Esc · Q" : "Esc back  Q quit";
         if (s.beside && !compact)
-            return "F focus beside  X detach it  ? keys  q quit";
+            return "T sessions  F focus right  X detach all  ? keys  q quit";
         if (s.beside)
             return "F X ? q";
         if (view === "file")
@@ -1416,6 +1476,8 @@ export function App(props) {
                     ? "…"
                     : "read-only"
         : "";
-    return (_jsxs(Box, { flexDirection: "column", height: rows, width: columns, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "yellow", children: "miadi-chronicle" }), " ", _jsx(Text, { color: "gray", children: where }), s.beside ? (_jsxs(Text, { color: "cyan", children: [` · ⇆ ${cleanLine(s.beside.session)}`, s.beside.info ? ` · ${cleanLine(s.beside.info.command)} · ${idleFor(s.beside.info.activity)}` : ""] })) : null, readerLabel ? _jsx(Text, { color: s.reader ? "green" : "gray", children: ` · ${readerLabel}` }) : null] }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: s.inputMode ? "yellow" : "gray", children: "/ " }), cleanLine(s.query), s.inputMode ? _jsx(Text, { inverse: true, children: " " }) : null, " ", s.view === "attention" ? (_jsx(Text, { color: "gray", children: "attention" })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: s.searchMode === "title" ? "yellow" : "gray", children: "title" }), _jsx(Text, { color: "gray", children: compact ? "|" : " | " }), _jsx(Text, { color: s.searchMode === "full" ? "yellow" : "gray", children: compact ? "full" : "full text" })] })), s.view === "list" ? _jsxs(Text, { color: "gray", children: [" \u00B7 ", d.filtered.length] }) : null, s.relateFrom ? _jsxs(Text, { color: "red", children: [" \u00B7 relating ", episodeLabel(s.relateFrom), " \u2192 L"] }) : null, s.view === "attention" ? _jsxs(Text, { color: "gray", children: [" \u00B7 ", d.board.length] }) : null] }), _jsx(Box, { flexDirection: "row", height: bodyHeight, overflow: "hidden", children: body }), _jsx(Text, { color: "gray", wrap: "truncate-end", children: s.status }), _jsxs(Text, { wrap: "truncate-end", children: [(s.overlays.length ? [] : available).map((action) => (_jsxs(Text, { children: [_jsx(Text, { color: action.effect === "write" ? "red" : "yellow", children: action.key === "Enter" ? "⏎" : action.key }), " ", action.label, "  "] }, action.id))), _jsx(Text, { color: "gray", children: hints })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", height: rows, width: columns, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { bold: true, color: "yellow", children: "miadi-chronicle" }), " ", _jsx(Text, { color: "gray", children: where }), s.beside ? (_jsxs(Text, { color: "cyan", children: [` · ⇆ `, s.beside.slots
+                                .map((slot) => `${cleanLine(slot.session)}${slot.info ? ` · ${cleanLine(slot.info.command)} · ${idleFor(slot.info.activity)}` : ""}`)
+                                .join(" | ")] })) : null, readerLabel ? _jsx(Text, { color: s.reader ? "green" : "gray", children: ` · ${readerLabel}` }) : null] }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: s.inputMode ? "yellow" : "gray", children: "/ " }), cleanLine(s.query), s.inputMode ? _jsx(Text, { inverse: true, children: " " }) : null, " ", s.view === "attention" ? (_jsx(Text, { color: "gray", children: "attention" })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: s.searchMode === "title" ? "yellow" : "gray", children: "title" }), _jsx(Text, { color: "gray", children: compact ? "|" : " | " }), _jsx(Text, { color: s.searchMode === "full" ? "yellow" : "gray", children: compact ? "full" : "full text" })] })), s.view === "list" ? _jsxs(Text, { color: "gray", children: [" \u00B7 ", d.filtered.length] }) : null, s.relateFrom ? _jsxs(Text, { color: "red", children: [" \u00B7 relating ", episodeLabel(s.relateFrom), " \u2192 L"] }) : null, s.view === "attention" ? _jsxs(Text, { color: "gray", children: [" \u00B7 ", d.board.length] }) : null] }), _jsx(Box, { flexDirection: "row", height: bodyHeight, overflow: "hidden", children: body }), _jsx(Text, { color: "gray", wrap: "truncate-end", children: s.status }), _jsxs(Text, { wrap: "truncate-end", children: [(s.overlays.length ? [] : available).map((action) => (_jsxs(Text, { children: [_jsx(Text, { color: action.effect === "write" ? "red" : "yellow", children: action.key === "Enter" ? "⏎" : action.key }), " ", action.label, "  "] }, action.id))), _jsx(Text, { color: "gray", children: hints })] })] }));
 }
 //# sourceMappingURL=App.js.map