@haywoodmarx/agent-pager 0.1.0

package/dist/src/tui/agent-tree.js

@@ -0,0 +1,663 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "@opentui/react/jsx-runtime";
+import { useKeyboard, useTerminalDimensions } from "@opentui/react";
+import { archivedOperatorRepositoryIds, isOperatorAgentArchived, operatorArchiveReason, } from "../operator/agent-projection.js";
+import { Line, Overlay, fitOverlayColumns, PaneBar, Rule, SCROLLBAR_RESERVED_COLUMNS, VERTICAL_SCROLL_STYLE, useTuiModel, } from "./chrome.js";
+import { AGENT_TREE_COLUMNS, IDENTITY_LABEL_GUTTER, agentColor, agentDetail, agentHandleText, formatClock, padCells, SELECTION_GUTTER_GLYPH, stepWrappingIndex, truncateCells, } from "./presentation.js";
+/**
+ * Group projected agents under their projected repositories in stable registration order.
+ * @param snapshot - Authoritative projection currently installed by the client model.
+ * @returns Repository groups suitable for the tree presentation.
+ */
+export function selectTuiRepositoryAgentGroups(snapshot) {
+    if (!snapshot)
+        return [];
+    const agentsByRepository = new Map();
+    for (const agent of snapshot.agents) {
+        const agents = agentsByRepository.get(agent.repository.repositoryId) ?? [];
+        agents.push(agent);
+        agentsByRepository.set(agent.repository.repositoryId, agents);
+    }
+    const groups = snapshot.repositories.map((repository) => {
+        const agents = agentsByRepository.get(repository.id) ?? [];
+        return {
+            repository,
+            active: agents.filter((agent) => !isOperatorAgentArchived(agent)),
+            archived: agents.filter((agent) => isOperatorAgentArchived(agent)),
+        };
+    });
+    // Archived workspaces sink below the ones still working, the same way an archived agent sits below
+    // its peers. Neither ordering is stable-sorted by anything else, so the projection's order holds
+    // within each half.
+    return [...groups.filter((group) => !isArchivedGroup(group)), ...groups.filter(isArchivedGroup)];
+}
+/**
+ * Report the state one workspace's archive section takes when the operator has stored no preference.
+ *
+ * A workspace with nothing still working has its archive open, since the section holds everything the
+ * workspace has; anywhere else it starts closed.
+ * @param group - Repository and its agents, already split by archive membership.
+ * @returns - The section's default state.
+ */
+function archivedSectionDefault(group) {
+    return group.active.length === 0 ? "open" : "closed";
+}
+/**
+ * Report whether one workspace's archive section is open: its stored preference, or else its default.
+ * @param view - Local view state holding the operator's archive preferences.
+ * @param group - Repository and its agents, already split by archive membership.
+ * @returns - Whether the section shows its agents.
+ */
+export function isTuiArchivedSectionOpen(view, group) {
+    return (view.archivedSections.get(group.repository.id) ?? archivedSectionDefault(group)) === "open";
+}
+/**
+ * Report whether a workspace is archived, which is to say every conversation in it is.
+ * @param group - Repository and its agents, already split by archive membership.
+ * @returns - Whether the workspace holds archived agents and no others.
+ */
+export function isArchivedGroup(group) {
+    return archivedOperatorRepositoryIds([...group.active, ...group.archived]).has(group.repository.id);
+}
+/**
+ * Select visible rows in tree order from model-owned expansion state.
+ * @param state - Current projection and local view state.
+ * @returns Rows available to keyboard navigation.
+ */
+export function selectVisibleTuiAgentTreeRows(state) {
+    const rows = [];
+    const hidden = state.view.hiddenRepositories;
+    for (const group of selectTuiRepositoryAgentGroups(state.snapshot)) {
+        if (hidden.has(group.repository.id))
+            continue;
+        rows.push({ kind: "workspace", repositoryId: group.repository.id });
+        if (state.view.collapsedRepositories.has(group.repository.id))
+            continue;
+        for (const agent of group.active)
+            rows.push({ kind: "agent", agentId: agent.id });
+        if (group.archived.length > 0) {
+            rows.push({ kind: "archived", repositoryId: group.repository.id });
+            if (isTuiArchivedSectionOpen(state.view, group))
+                for (const agent of group.archived)
+                    rows.push({ kind: "agent", agentId: agent.id });
+        }
+    }
+    const hiddenGroups = selectTuiRepositoryAgentGroups(state.snapshot).filter((group) => hidden.has(group.repository.id));
+    if (hiddenGroups.length === 0)
+        return rows;
+    rows.push({ kind: "hidden" });
+    if (state.view.hiddenExpanded)
+        for (const group of hiddenGroups)
+            rows.push({ kind: "workspace", repositoryId: group.repository.id });
+    return rows;
+}
+/**
+ * Report the workspace or archive section a tree selection can expand and collapse.
+ * @param state - Current authoritative projection and local presentation state.
+ * @returns The collapsible row's kind and repository, or null when the selection cannot collapse.
+ */
+export function selectTuiCollapsibleSelection(state) {
+    const selection = state.view.selection;
+    if (selection?.kind !== "workspace" && selection?.kind !== "archived")
+        return null;
+    // A hidden workspace shows no children in the section, so there is nothing to expand into.
+    if (selection.kind === "workspace" && state.view.hiddenRepositories.has(selection.repositoryId))
+        return null;
+    return { kind: selection.kind, repositoryId: selection.repositoryId };
+}
+/**
+ * Reduce one workspace context action.
+ *
+ * Hiding puts a workspace in the section at the foot of the tree and takes the selection to the
+ * section header, because the row the operator was on is no longer where they left it.
+ * @param state - Current model state.
+ * @param action - Action chosen from the workspace menu.
+ * @returns - Next view state.
+ */
+function reduceWorkspaceContextAction(state, action) {
+    const view = state.view;
+    const overlay = view.overlay;
+    if (overlay.kind !== "context_menu" || overlay.target !== "workspace")
+        return { view };
+    const hidden = new Set(view.hiddenRepositories);
+    const close = { ...view, focus: view.overlayReturnFocus, overlay: { kind: "none" }, contextActionIndex: 0 };
+    if (action === "hide") {
+        hidden.add(overlay.repositoryId);
+        return { view: { ...close, ...rescopedAgentLog, hiddenRepositories: hidden, selection: { kind: "hidden" } } };
+    }
+    hidden.delete(overlay.repositoryId);
+    return {
+        view: {
+            ...close,
+            ...rescopedAgentLog,
+            hiddenRepositories: hidden,
+            selection: { kind: "workspace", repositoryId: overlay.repositoryId },
+        },
+    };
+}
+/**
+ * Execute one already-reduced tree result through the model and broker delegate.
+ * @param model - Model that owns the local view state.
+ * @param onCommand - Submits a broker-owned command on the tree's behalf.
+ * @param result - Reducer result shared by keyboard and pointer actions.
+ */
+export function executeAgentTreeResult(model, onCommand, result) {
+    if (result.view !== model.state.view)
+        model.updateView(() => result.view);
+    if (result.command)
+        onCommand(result.command);
+}
+/**
+ * Toggle an archive section, by the same rule for every input source.
+ *
+ * Only a choice that departs from the section's current default is kept. A section the operator closes
+ * while its workspace still has working agents is closed by default anyway, so nothing is recorded, and
+ * it opens by default once the last of those agents is archived.
+ * @param state - Current authoritative facts and local view state.
+ * @param repositoryId - Repository whose archive section is toggled.
+ * @returns A model-owned view update.
+ */
+function reduceAgentTreeArchivedToggle(state, repositoryId) {
+    const view = state.view;
+    const group = selectTuiRepositoryAgentGroups(state.snapshot).find((candidate) => candidate.repository.id === repositoryId);
+    if (!group)
+        return { view };
+    const sections = new Map(view.archivedSections);
+    const next = isTuiArchivedSectionOpen(view, group) ? "closed" : "open";
+    if (next === archivedSectionDefault(group))
+        sections.delete(repositoryId);
+    else
+        sections.set(repositoryId, next);
+    return { view: { ...view, archivedSections: sections } };
+}
+/**
+ * Reduce a context-menu action for both keyboard and pointer activation.
+ * @param state - Current authoritative facts and local view state.
+ * @param action - Context action selected by the user.
+ * @returns The next local view and optional broker ping request.
+ */
+export function reduceAgentTreeContextAction(state, action) {
+    const view = state.view;
+    const overlay = view.overlay;
+    if (overlay.kind !== "context_menu" || overlay.target !== "agent")
+        return { view };
+    const agent = state.snapshot?.agents.find((entry) => entry.id === overlay.agentId);
+    if (!agent)
+        return { view };
+    const close = { ...view, focus: view.overlayReturnFocus, overlay: { kind: "none" }, contextActionIndex: 0 };
+    if (action === "ping")
+        return { view: close, command: { type: "ping_agent", targetAgentId: agent.id } };
+    if (action === "details")
+        return { view: { ...view, overlay: { kind: "agent_identity", agentId: agent.id } } };
+    // Archiving is confirmed in an overlay of its own rather than committed by the keypress that
+    // selected it.
+    if (action === "archive")
+        return { view: { ...view, overlay: { kind: "archive_confirm", agentId: agent.id } } };
+    const archived = isOperatorAgentArchived(agent);
+    const collapsedRepositories = new Set(view.collapsedRepositories);
+    if (!archived)
+        collapsedRepositories.add(agent.repository.repositoryId);
+    const archivedView = archived ? reduceAgentTreeArchivedToggle(state, agent.repository.repositoryId).view : view;
+    return {
+        view: {
+            ...close,
+            collapsedRepositories,
+            archivedSections: archivedView.archivedSections,
+            ...rescopedAgentLog,
+            selection: { kind: archived ? "archived" : "workspace", repositoryId: agent.repository.repositoryId },
+        },
+    };
+}
+/**
+ * Reduce one keyboard command without depending on an OpenTUI input source.
+ * @param state - Current authoritative projection and local presentation state.
+ * @param key - Normalized OpenTUI key name.
+ * @returns The next model-owned view and an optional broker command, a ping or an archive.
+ */
+export function reduceAgentTreeKey(state, key) {
+    const view = state.view;
+    const selectedAgentId = view.selection?.kind === "agent" ? view.selection.agentId : undefined;
+    const agent = selectedAgentId ? state.snapshot?.agents.find((entry) => entry.id === selectedAgentId) : undefined;
+    const close = () => ({
+        view: { ...view, focus: view.overlayReturnFocus, overlay: { kind: "none" }, contextActionIndex: 0 },
+    });
+    if (view.overlay.kind === "agent_identity") {
+        if (key === "escape")
+            return close();
+        return key === "p" ? { view, command: { type: "ping_agent", targetAgentId: view.overlay.agentId } } : { view };
+    }
+    if (view.overlay.kind === "archive_confirm") {
+        const target = view.overlay.agentId;
+        if (key === "escape")
+            return close();
+        if (!activates(key))
+            return { view };
+        const closed = close();
+        return {
+            view: { ...closed.view, ...rescopedAgentLog, selection: selectionAfterArchive(state, target) },
+            command: { type: "archive_agent", targetAgentId: target },
+        };
+    }
+    if (view.overlay.kind === "context_menu" && view.overlay.target === "workspace") {
+        if (key === "escape")
+            return close();
+        if (!activates(key))
+            return { view };
+        return reduceWorkspaceContextAction(state, workspaceContextActions(state)[0] ?? "hide");
+    }
+    // The message menu shares this overlay kind, and its own component answers its keys.
+    if (view.overlay.kind === "context_menu" && view.overlay.target === "agent") {
+        if (key === "escape")
+            return close();
+        if (key === "up" || key === "down")
+            return {
+                view: {
+                    ...view,
+                    contextActionIndex: stepWrappingIndex(view.contextActionIndex, key === "up" ? "up" : "down", contextActions.length),
+                },
+            };
+        if (!activates(key))
+            return { view };
+        const action = contextActions[view.contextActionIndex];
+        return action ? reduceAgentTreeContextAction(state, action) : { view };
+    }
+    // Overlays the shell owns take the keyboard whole: answering here would act behind one, or replace
+    // it with an overlay of the tree's own.
+    if (view.overlay.kind !== "none")
+        return { view };
+    if (view.focus !== "tree")
+        return { view };
+    const rows = selectVisibleTuiAgentTreeRows(state);
+    const select = (row) => ({
+        view: {
+            ...view,
+            ...rescopedAgentLog,
+            selection: rowSelection(row),
+        },
+    });
+    if (key === "up" || key === "down") {
+        const current = rows.findIndex((row) => JSON.stringify(rowSelection(row)) === JSON.stringify(view.selection));
+        const step = current < 0 ? 0 : current + (key === "up" ? -1 : 1);
+        const next = rows[Math.min(Math.max(step, 0), rows.length - 1)];
+        return next ? select(next) : { view };
+    }
+    if (key === "p" && agent)
+        return { view, command: { type: "ping_agent", targetAgentId: agent.id } };
+    if (key === "i" && agent)
+        return { view: { ...view, overlay: { kind: "agent_identity", agentId: agent.id }, overlayReturnFocus: view.focus } };
+    if (key === "a" && agent)
+        return {
+            view: {
+                ...view,
+                overlay: { kind: "context_menu", target: "agent", agentId: agent.id },
+                overlayReturnFocus: view.focus,
+                contextActionIndex: 0,
+            },
+        };
+    if (key === "a" && view.selection?.kind === "workspace")
+        return {
+            view: {
+                ...view,
+                overlay: { kind: "context_menu", target: "workspace", repositoryId: view.selection.repositoryId },
+                overlayReturnFocus: view.focus,
+                contextActionIndex: 0,
+            },
+        };
+    if (view.selection?.kind === "hidden" && activates(key))
+        return { view: { ...view, hiddenExpanded: !view.hiddenExpanded } };
+    const collapsible = selectTuiCollapsibleSelection(state);
+    if (collapsible && activates(key)) {
+        if (collapsible.kind === "archived")
+            return reduceAgentTreeArchivedToggle(state, collapsible.repositoryId);
+        const collapsed = new Set(view.collapsedRepositories);
+        if (collapsed.has(collapsible.repositoryId))
+            collapsed.delete(collapsible.repositoryId);
+        else
+            collapsed.add(collapsible.repositoryId);
+        return { view: { ...view, collapsedRepositories: collapsed } };
+    }
+    return { view };
+}
+/**
+ * Render projected repositories, agents, archive sections, identity, and row actions.
+ * @param properties - Model, palette, and broker command delegate.
+ * @returns OpenTUI terminal presentation for the agent tree.
+ */
+export function AgentTree({ model, theme, onCommand, colorEnabled = true, width = AGENT_TREE_COLUMNS, }) {
+    const state = useTuiModel(model);
+    const all = selectTuiRepositoryAgentGroups(state.snapshot);
+    const groups = all.filter((group) => !state.view.hiddenRepositories.has(group.repository.id));
+    const hiddenGroups = all.filter((group) => state.view.hiddenRepositories.has(group.repository.id));
+    const focus = state.view.focus === "tree";
+    const update = (updateView) => {
+        model.updateView(updateView);
+    };
+    const selectAgent = (agent) => {
+        update((view) => ({
+            ...view,
+            ...rescopedAgentLog,
+            focus: "tree",
+            selection: { kind: "agent", agentId: agent.id },
+        }));
+    };
+    const toggleArchivedSection = (repository) => {
+        const result = reduceAgentTreeArchivedToggle(model.state, repository.id);
+        model.updateView(() => ({ ...result.view, focus: "tree" }));
+    };
+    const openContext = (agent) => {
+        update((view) => ({
+            ...view,
+            focus: "tree",
+            selection: { kind: "agent", agentId: agent.id },
+            overlay: { kind: "context_menu", target: "agent", agentId: agent.id },
+            overlayReturnFocus: view.focus,
+            contextActionIndex: 0,
+        }));
+    };
+    useKeyboard((key) => {
+        // The shell owns row movement so one key has one owner; the tree still answers it inside an overlay.
+        if ((key.name === "up" || key.name === "down") && model.state.view.overlay.kind === "none")
+            return;
+        // Every pane's handler receives this same key, and a reduction carries a whole view, so one
+        // taken from the rendered snapshot overwrites whatever another handler decided.
+        const result = reduceAgentTreeKey(model.state, key.name);
+        executeAgentTreeResult(model, onCommand, result);
+    });
+    // A tree whose every workspace is hidden still draws the hidden section, the only way to bring one back.
+    if (all.length === 0)
+        return (_jsx("box", { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsx("text", { fg: theme.structure.rulesAndLabels, children: "no agents connected" }) }));
+    return (_jsxs("box", { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: [_jsx("box", { paddingLeft: 1, paddingRight: 1, flexShrink: 0, children: _jsx(Line, { children: _jsx("text", { fg: theme.structure.rulesAndLabels, children: "AGENTS" }) }) }), _jsx(Line, {}), _jsxs("scrollbox", { flexGrow: 1, focused: focus, paddingLeft: 1, paddingRight: 1, style: VERTICAL_SCROLL_STYLE, children: [groups.map((group) => (_jsx(RepositoryRows, { group: group, state: state, theme: theme, colorEnabled: colorEnabled, width: width, onToggleArchived: toggleArchivedSection, onSelectRepository: (repository) => update((view) => ({
+                            ...view,
+                            focus: "tree",
+                            ...rescopedAgentLog,
+                            selection: { kind: "workspace", repositoryId: repository.id },
+                        })), onSelectAgent: selectAgent, onContext: openContext }, group.repository.id))), hiddenGroups.length > 0 ? (_jsx(HiddenRows, { groups: hiddenGroups, state: state, theme: theme, width: width, onToggle: () => {
+                            update((view) => ({ ...view, focus: "tree", hiddenExpanded: !view.hiddenExpanded }));
+                        }, onSelectRepository: (repository) => update((view) => ({
+                            ...view,
+                            focus: "tree",
+                            ...rescopedAgentLog,
+                            selection: { kind: "workspace", repositoryId: repository.id },
+                        })), onContext: (repository) => update((view) => ({
+                            ...view,
+                            focus: "tree",
+                            selection: { kind: "workspace", repositoryId: repository.id },
+                            overlay: { kind: "context_menu", target: "workspace", repositoryId: repository.id },
+                            overlayReturnFocus: view.focus,
+                            contextActionIndex: 0,
+                        })) })) : null] })] }));
+}
+/**
+ * Render the section holding workspaces the operator put out of sight.
+ * @param properties - Hidden groups, model state, palette, width, and the row callbacks.
+ * @returns Section header and, while open, one row per hidden workspace.
+ */
+function HiddenRows({ groups, state, theme, width, onToggle, onSelectRepository, onContext, }) {
+    const focused = state.view.focus === "tree";
+    const headerSelected = state.view.selection?.kind === "hidden";
+    const expanded = state.view.hiddenExpanded;
+    return (_jsxs("box", { flexDirection: "column", children: [_jsxs("box", { height: 1, flexDirection: "row", onMouseDown: onToggle, children: [_jsx(SelectionGutter, { marked: headerSelected, theme: theme }), _jsx("box", { flexGrow: 1, flexDirection: "row", ...(headerSelected && focused ? { backgroundColor: theme.structure.selection.background } : {}), children: _jsx("text", { fg: headerSelected && focused ? theme.structure.selection.text : theme.structure.rulesAndLabels, children: `${expanded ? "▾" : "▸"} hidden · ${String(groups.length)}` }) })] }), expanded
+                ? groups.map((group) => {
+                    const selected = state.view.selection?.kind === "workspace" && state.view.selection.repositoryId === group.repository.id;
+                    return (_jsxs("box", { height: 1, flexDirection: "row", onMouseDown: (event) => {
+                            if (event.button === 2)
+                                onContext(group.repository);
+                            else
+                                onSelectRepository(group.repository);
+                        }, children: [_jsx(SelectionGutter, { marked: selected, theme: theme }), _jsx("box", { flexGrow: 1, flexDirection: "row", ...(selected && focused ? { backgroundColor: theme.structure.selection.background } : {}), children: _jsx("text", { fg: selected && focused ? theme.structure.selection.text : theme.structure.rulesAndLabels, children: `  ${truncateCells(group.repository.name, width - 6 - SCROLLBAR_RESERVED_COLUMNS)}` }) })] }, group.repository.id));
+                })
+                : null] }));
+}
+/**
+ * Render the tree-owned modal at the terminal root rather than inside the fixed pane.
+ * @param properties - Model state and palette shared with the agent-tree pane.
+ * @returns The overlay the tree owns for the current view state, or nothing when the open overlay is not the tree's.
+ */
+export function AgentTreeOverlay({ model, theme, onCommand, colorEnabled = true }) {
+    const state = useTuiModel(model);
+    const overlay = state.view.overlay;
+    if (overlay.kind === "agent_identity")
+        return (_jsx(AgentIdentityOverlay, { agent: state.snapshot?.agents.find((agent) => agent.id === overlay.agentId), repository: state.snapshot?.repositories.find((repository) => repository.id ===
+                state.snapshot?.agents.find((agent) => agent.id === overlay.agentId)?.repository.repositoryId), theme: theme, colorEnabled: colorEnabled }));
+    if (overlay.kind === "archive_confirm")
+        return (_jsx(ArchiveConfirmOverlay, { agent: state.snapshot?.agents.find((agent) => agent.id === overlay.agentId), theme: theme }));
+    if (overlay.kind === "context_menu" && overlay.target === "workspace")
+        return (_jsx(WorkspaceContextOverlay, { actions: workspaceContextActions(state), theme: theme, onAction: (action) => executeAgentTreeResult(model, onCommand, reduceWorkspaceContextAction(model.state, action)) }));
+    return overlay.kind === "context_menu" && overlay.target === "agent" ? (_jsx(AgentContextOverlay, { actionIndex: state.view.contextActionIndex, theme: theme, onAction: (action) => executeAgentTreeResult(model, onCommand, reduceAgentTreeContextAction(model.state, action)) })) : null;
+}
+function RepositoryRows({ group, state, theme, colorEnabled, width, onToggleArchived, onSelectRepository, onSelectAgent, onContext, }) {
+    const expanded = !state.view.collapsedRepositories.has(group.repository.id);
+    const archivedExpanded = isTuiArchivedSectionOpen(state.view, group);
+    const focused = state.view.focus === "tree";
+    const selectedRepository = state.view.selection?.kind === "workspace" && state.view.selection.repositoryId === group.repository.id;
+    const archivedSelected = state.view.selection?.kind === "archived" && state.view.selection.repositoryId === group.repository.id;
+    const repositoryColor = selectedRepository && focused
+        ? theme.structure.selection.text
+        : isArchivedGroup(group)
+            ? theme.structure.rulesAndLabels
+            : theme.structure.bodyText;
+    const archivedColor = archivedSelected && focused ? theme.structure.selection.text : theme.structure.rulesAndLabels;
+    return (_jsxs("box", { flexDirection: "column", children: [_jsxs("box", { height: 1, flexDirection: "row", onMouseDown: () => onSelectRepository(group.repository), children: [_jsx(SelectionGutter, { marked: selectedRepository, theme: theme }), _jsx("box", { flexGrow: 1, flexDirection: "row", ...(selectedRepository && focused ? { backgroundColor: theme.structure.selection.background } : {}), children: _jsx("text", { fg: repositoryColor, children: `${expanded ? "▾" : "▸"} ${truncateCells(group.repository.name, width - 6 - SCROLLBAR_RESERVED_COLUMNS)}` }) })] }), expanded
+                ? group.active.map((agent, index) => (_jsx(AgentRow, { agent: agent, state: state, theme: theme, colorEnabled: colorEnabled, width: width, last: group.archived.length === 0 && index === group.active.length - 1, onSelect: onSelectAgent, onContext: onContext }, agent.id)))
+                : null, expanded && group.archived.length > 0 ? (_jsxs(_Fragment, { children: [_jsxs("box", { height: 1, flexDirection: "row", onMouseDown: () => onToggleArchived(group.repository), children: [_jsx(SelectionGutter, { marked: archivedSelected, theme: theme }), _jsx("box", { flexGrow: 1, flexDirection: "row", ...(archivedSelected && focused ? { backgroundColor: theme.structure.selection.background } : {}), children: _jsx("text", { fg: archivedColor, children: `└ ${archivedExpanded ? "▾" : "▸"} archived · ${String(group.archived.length)}` }) })] }), archivedExpanded
+                        ? group.archived.map((agent, index) => (_jsx(ArchivedAgentRow, { agent: agent, last: index === group.archived.length - 1, state: state, theme: theme, width: width, onSelect: onSelectAgent, onContext: onContext }, agent.id)))
+                        : null] })) : null, _jsx("box", { height: 1 })] }));
+}
+/**
+ * Render the one-cell selection gutter every tree row reserves.
+ *
+ * A pane marks its selection with a fill only while it holds focus; elsewhere the selection persists
+ * as this bar, which is also what tells the operator which pane focus is in. It carries the fill's
+ * own colour and sits outside it, so it reads as a sliver of the highlight rather than a separate
+ * mark, and a highlighted row keeps the same leading edge as an unhighlighted one.
+ * @param root0 - Marker state and the palette supplying its colour.
+ * @returns One character cell carrying the marker or a blank.
+ */
+function SelectionGutter({ marked, theme }) {
+    return _jsx("text", { fg: theme.structure.selection.background, children: marked ? SELECTION_GUTTER_GLYPH : " " });
+}
+function AgentRow({ agent, state, theme, colorEnabled, width, last, onSelect, onContext, }) {
+    const selected = state.view.selection?.kind === "agent" && state.view.selection.agentId === agent.id;
+    const health = state.healthByAgentId.get(agent.id)?.kind ?? "neutral";
+    // While the broker is unreachable the held health is the last thing it said, not something it is
+    // saying. Incompatible is not a transient state a reconnect will resolve: the stream has stopped
+    // for good, so the held health is just as stale as it is mid-recovery.
+    const stale = state.connection === "recovering" || state.connection === "incompatible";
+    const handle = agentHandleText(agent.alias);
+    const focused = state.view.focus === "tree";
+    const rowColor = selected && focused ? theme.structure.selection.text : theme.structure.rulesAndLabels;
+    const room = width - 3 - SCROLLBAR_RESERVED_COLUMNS - TREE_STATE_COLUMN;
+    const prefix = last ? "└ " : "├ ";
+    return (_jsxs("box", { height: 1, flexDirection: "row", onMouseDown: (event) => {
+            if (event.button === 2)
+                onContext(agent);
+            else
+                onSelect(agent);
+        }, children: [_jsx(SelectionGutter, { marked: selected, theme: theme }), _jsxs("box", { flexGrow: 1, flexDirection: "row", ...(selected && focused ? { backgroundColor: theme.structure.selection.background } : {}), children: [_jsxs("text", { flexGrow: 1, fg: rowColor, children: [prefix, _jsx("span", { fg: colorEnabled ? agentColor(agent.id, theme) : theme.structure.bodyText, children: truncateCells(handle, Math.max(1, room - prefix.length)) })] }), _jsx("text", { fg: stale ? theme.structure.rulesAndLabels : healthColor(health, theme), children: `${stale ? UNKNOWN_HEALTH_GLYPH : healthGlyph(health) || " "} ` })] })] }));
+}
+function ArchivedAgentRow({ agent, last, state, theme, width, onSelect, onContext, }) {
+    const focused = state.view.focus === "tree";
+    const selected = state.view.selection?.kind === "agent" && state.view.selection.agentId === agent.id;
+    const rowColor = selected && focused ? theme.structure.selection.text : theme.structure.rulesAndLabels;
+    const lastSeenAt = agent.adapter.lastSeenAt;
+    const row = `   ${last ? "└" : "├"} @${agent.alias} ${agentDetail(agent)}${lastSeenAt === null ? "" : ` · ${formatClock(lastSeenAt)}`}`;
+    return (_jsxs("box", { height: 1, flexDirection: "row", onMouseDown: (event) => {
+            if (event.button === 2)
+                onContext(agent);
+            else
+                onSelect(agent);
+        }, children: [_jsx(SelectionGutter, { marked: selected, theme: theme }), _jsx("box", { flexGrow: 1, flexDirection: "row", ...(selected && focused ? { backgroundColor: theme.structure.selection.background } : {}), children: _jsx("text", { fg: rowColor, children: truncateCells(row, width - 3 - SCROLLBAR_RESERVED_COLUMNS) }) })] }));
+}
+function AgentIdentityOverlay({ agent, repository, theme, colorEnabled, }) {
+    const terminal = useTerminalDimensions();
+    if (!agent)
+        return null;
+    // Border and padding take two cells on each side of the fitted overlay.
+    const valueColumns = fitOverlayColumns(IDENTITY_OVERLAY_COLUMNS, terminal.width) - 4 - IDENTITY_LABEL_GUTTER;
+    const implementation = agent.implementation.available
+        ? agent.implementation.displayName
+        : (agent.implementation.id ?? "unavailable");
+    const status = archiveStatusLabel(agent);
+    const fields = [
+        ["agent id", agent.id],
+        ["harness", implementation],
+        ["workspace", repository ? repository.name : agent.repository.repositoryId],
+        ["worktree", agent.repository.worktree.path ?? "repository root"],
+        ["status", status],
+    ];
+    return (_jsxs(Overlay, { theme: theme, width: IDENTITY_OVERLAY_COLUMNS, children: [_jsx(PaneBar, { left: _jsx("text", { fg: colorEnabled ? agentColor(agent.id, theme) : theme.structure.emphasis, children: agentHandleText(agent.alias) }), right: _jsx("text", { fg: theme.structure.rulesAndLabels, children: "esc" }) }), _jsx(Rule, { theme: theme }), _jsx("box", { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: fields.map(([label, value], index) => (_jsx(Line, { children: _jsxs("text", { fg: index === 0 ? theme.structure.emphasis : theme.structure.bodyText, children: [_jsx("span", { fg: theme.structure.rulesAndLabels, children: padCells(label, IDENTITY_LABEL_GUTTER) }), truncateCells(value, valueColumns)] }) }, label))) }), _jsx(Rule, { theme: theme }), _jsxs("box", { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [_jsx(Line, { children: _jsx("text", { fg: theme.structure.rulesAndLabels, children: "previous handles" }) }), agent.previousAliases.length === 0 ? (_jsx(Line, { children: _jsx("text", { fg: theme.structure.rulesAndLabels, children: "none" }) })) : (agent.previousAliases.map((alias) => (_jsx(Line, { children: _jsx("text", { fg: theme.structure.bodyText, children: agentHandleText(alias) }) }, alias))))] }), _jsx(Rule, { theme: theme }), _jsx(PaneBar, { left: _jsx("text", { fg: theme.structure.rulesAndLabels, children: IDENTITY_FOOTER_KEYS }), right: null })] }));
+}
+/** Keys a row-action menu advertises in its footer. */
+export const CONTEXT_FOOTER_KEYS = "⏎ select";
+/** Keys the agent identity modal advertises in its footer. */
+const IDENTITY_FOOTER_KEYS = "p ping inbox";
+/** Keys the archive confirmation advertises in its footer. */
+const ARCHIVE_CONFIRM_FOOTER_KEYS = "⏎ archive  esc cancel";
+const ARCHIVE_OVERLAY_COLUMNS = 34;
+/**
+ * Ask again before an archive, since it detaches the agent's live session and moves its row into
+ * the workspace's archived section until the conversation reattaches or the broker reaps the agent
+ * after its retention window.
+ * @param properties - Agent being archived, and the palette to draw with.
+ * @returns - Confirmation overlay, or nothing when the agent has left the snapshot.
+ */
+function ArchiveConfirmOverlay({ agent, theme, }) {
+    if (!agent)
+        return null;
+    return (_jsxs(Overlay, { theme: theme, width: ARCHIVE_OVERLAY_COLUMNS, children: [_jsx(PaneBar, { left: _jsx("text", { fg: theme.states.failed, children: `archive ${agentHandleText(agent.alias)}?` }), right: null }), _jsx(Rule, { theme: theme }), _jsx(PaneBar, { left: _jsx("text", { fg: theme.structure.rulesAndLabels, children: ARCHIVE_CONFIRM_FOOTER_KEYS }), right: null })] }));
+}
+const contextActions = ["ping", "details", "archive", "collapse"];
+/**
+ * List the actions offered for the workspace the menu was opened on.
+ * @param state - Current model state, holding what is hidden.
+ * @returns - The one action that applies, in a list so the menu never names a specific action.
+ */
+export function workspaceContextActions(state) {
+    const overlay = state.view.overlay;
+    if (overlay.kind !== "context_menu" || overlay.target !== "workspace")
+        return [];
+    return [state.view.hiddenRepositories.has(overlay.repositoryId) ? "unhide" : "hide"];
+}
+const workspaceContextActionLabels = {
+    hide: "hide workspace",
+    unhide: "unhide workspace",
+};
+const contextActionLabels = {
+    ping: "ping inbox",
+    details: "details",
+    archive: "archive agent",
+    collapse: "collapse workspace",
+};
+function WorkspaceContextOverlay({ actions, theme, onAction, }) {
+    return (_jsxs(Overlay, { theme: theme, width: CONTEXT_OVERLAY_COLUMNS, children: [_jsx(PaneBar, { left: _jsx("text", { fg: theme.structure.emphasis, children: "Actions" }), right: _jsx("text", { fg: theme.structure.rulesAndLabels, children: "esc" }) }), _jsx(Rule, { theme: theme }), actions.map((action) => (_jsx("box", { height: 1, backgroundColor: theme.structure.selection.background, onMouseDown: () => onAction(action), children: _jsx("text", { fg: theme.structure.selection.text, children: ` ${workspaceContextActionLabels[action]}` }) }, action))), _jsx(Rule, { theme: theme }), _jsx(PaneBar, { left: _jsx("text", { fg: theme.structure.rulesAndLabels, children: CONTEXT_FOOTER_KEYS }), right: null })] }));
+}
+function AgentContextOverlay({ actionIndex, theme, onAction, }) {
+    return (_jsxs(Overlay, { theme: theme, width: CONTEXT_OVERLAY_COLUMNS, children: [_jsx(PaneBar, { left: _jsx("text", { fg: theme.structure.emphasis, children: "Actions" }), right: _jsx("text", { fg: theme.structure.rulesAndLabels, children: "esc" }) }), _jsx(Rule, { theme: theme }), contextActions.map((action, index) => (_jsxs("box", { flexDirection: "column", children: [action === "collapse" ? _jsx(Rule, { theme: theme }) : null, _jsx("box", { height: 1, ...(index === actionIndex ? { backgroundColor: theme.structure.selection.background } : {}), onMouseDown: () => onAction(action), children: _jsx("text", { fg: index === actionIndex ? theme.structure.selection.text : theme.structure.emphasis, children: ` ${contextActionLabels[action]}` }) })] }, action))), _jsx(Rule, { theme: theme }), _jsx(PaneBar, { left: _jsx("text", { fg: theme.structure.rulesAndLabels, children: CONTEXT_FOOTER_KEYS }), right: null })] }));
+}
+/**
+ * Report whether a key activates the focused row or overlay.
+ *
+ * Terminals disagree on what they call the return key, and a branch that names only one of them
+ * silently does nothing on the other.
+ * @param key - Key name reported by the terminal.
+ * @returns - Whether the key means "activate this".
+ */
+function activates(key) {
+    return key === "enter" || key === "return";
+}
+/**
+ * Choose what the tree selects once an agent leaves its place in the list.
+ *
+ * The row below it, because that is where the eye already is. A workspace losing its last working
+ * conversation collapses, so its own row is the only thing left to land on.
+ * @param state - Current authoritative facts and local view state.
+ * @param agentId - Agent about to be archived.
+ * @returns - Selection to hold after the archive lands.
+ */
+function selectionAfterArchive(state, agentId) {
+    const agent = state.snapshot?.agents.find((entry) => entry.id === agentId);
+    if (!agent)
+        return state.view.selection;
+    const repositoryId = agent.repository.repositoryId;
+    const active = (state.snapshot?.agents ?? []).filter((entry) => entry.repository.repositoryId === repositoryId && !isOperatorAgentArchived(entry));
+    if (active.length <= 1)
+        return { kind: "workspace", repositoryId };
+    const rows = selectVisibleTuiAgentTreeRows(state);
+    const index = rows.findIndex((row) => row.kind === "agent" && row.agentId === agentId);
+    const next = index < 0 ? undefined : rows[index + 1];
+    return next ? rowSelection(next) : { kind: "workspace", repositoryId };
+}
+/**
+ * Report the selection one tree row stands for.
+ * @param row - Row the operator moved onto.
+ * @returns - Selection that names it.
+ */
+function rowSelection(row) {
+    if (row.kind === "agent")
+        return { kind: "agent", agentId: row.agentId };
+    if (row.kind === "hidden")
+        return { kind: "hidden" };
+    return { kind: row.kind, repositoryId: row.repositoryId };
+}
+/**
+ * Name an agent's status in the words the identity overlay uses.
+ * @param agent - Agent the overlay describes.
+ * @returns - The adapter's state for an active agent, or what put an archived one in the archive.
+ */
+function archiveStatusLabel(agent) {
+    switch (operatorArchiveReason(agent)) {
+        case null:
+            return agent.adapter.state;
+        case "operator":
+            return "archived by operator";
+        case "lifecycle":
+            return agent.lifecycle;
+        case "workspace_removed":
+            return "workspace removed";
+    }
+}
+const TREE_STATE_COLUMN = 2;
+/**
+ * Resets the agent log for the scope a tree move opens.
+ *
+ * The log now lists different traffic, so a message chosen under the previous scope is not a
+ * selection in it, and follow resumes because the operator never scrolled away from this list.
+ */
+const rescopedAgentLog = { trafficId: null, followAgentLog: true };
+const IDENTITY_OVERLAY_COLUMNS = 70;
+const CONTEXT_OVERLAY_COLUMNS = 26;
+/** Stands where a health glyph would while the broker cannot say what the agent's health is. */
+const UNKNOWN_HEALTH_GLYPH = "?";
+function healthGlyph(kind) {
+    switch (kind) {
+        case "connection_disconnected":
+            return "○";
+        case "delivery_queued":
+        case "delivery_claimed":
+            return "◐";
+        case "delivery_failed":
+            return "✕";
+        case "delivery_acknowledged":
+            return "●";
+        case "neutral":
+            // Connected, with no delivery outcome to report. Marked rather than blank so a live agent is never
+            // indistinguishable from one the row simply has nothing to say about.
+            return "·";
+        case "archived":
+            return "";
+    }
+}
+function healthColor(kind, theme) {
+    switch (kind) {
+        case "delivery_queued":
+        case "delivery_claimed":
+            return theme.states.inProgress;
+        case "delivery_failed":
+            return theme.states.failed;
+        case "delivery_acknowledged":
+            return theme.states.complete;
+        case "connection_disconnected":
+        case "archived":
+        case "neutral":
+            return theme.structure.rulesAndLabels;
+    }
+}