@softov/ahpc 0.2.0 → 0.4.0

package/dist/src/view/picker.js

@@ -1,71 +0,0 @@
-/**
- * The palette, moved.
- *
- * A chip on the composer's control row asks one question - which harness,
- * which model, how much it may do without asking, which workspace - and every
- * one of those is a command with an argument. The command palette already
- * knows how to ask about exactly that: `openAt` drills straight into an
- * argument, `choices` may be a list, a function or a promise, an argument
- * *without* choices is answered by typing, and `preview` shows what a
- * highlighted value would do.
- *
- * So this is not a second overlay. It is the same one, anchored above the
- * control that asked, and shown one command's question rather than the whole
- * registry. Anything registered later - a workspace list, a thinking level, a
- * subagent - is a command with an argument and needs nothing here.
- */
-export const PICKER = 'chat.picker';
-export function openPicker(app, options) {
-    const command = app.commands.get(options.commandId);
-    if (!command)
-        return;
-    // The chip that opened this one closes it. A control whose panel is already
-    // showing is a toggle - clicking it again to make it go away is the first
-    // thing anybody tries, and reopening it looks like the click did nothing.
-    const showing = app.layers.entries().find((entry) => entry.id === PICKER);
-    const already = showing?.node;
-    if (already?.openAt === options.commandId) {
-        app.layers.close(PICKER);
-        return;
-    }
-    // Closed first, so opening a second chip's panel replaces the first rather
-    // than stacking two of them with the same id.
-    app.layers.close(PICKER);
-    app.layers.open({
-        id: PICKER,
-        // Floating, not modal: there is no scrim, because the row it is asking
-        // about has to stay readable underneath it. Which value is in force is
-        // half of what makes the question answerable.
-        layer: 'floating',
-        trapFocus: true,
-        dismissOnEscape: true,
-        dismissOnOutsideClick: true,
-        // Above the chip, aligned to its left edge - so it rises out of the
-        // control rather than appearing somewhere else on the screen. A composer
-        // sits at the bottom, so `top` is the side with room.
-        position: { kind: 'anchor', targetId: options.anchorId, side: 'top', align: 'start' },
-        node: {
-            component: 'CommandPalette',
-            ...(options.width !== undefined ? { width: options.width } : {}),
-            maxWidth: options.maxWidth ?? 52,
-            visibleRows: options.visibleRows ?? 6,
-            // One command, so the panel opens on its values instead of on a search
-            // box with everything in it.
-            commands: [command],
-            openAt: options.commandId,
-            ...(options.descriptions ? { descriptions: options.descriptions } : {}),
-            onClose: { handler: () => app.layers.close(PICKER) },
-        },
-        // Back to the chip that asked, however it was closed.
-        //
-        // The layer's own scope restores focus when a choice is made, and does not
-        // when the panel is dismissed with escape - which strands the keyboard on
-        // a node inside a layer that is no longer there, and the next tab starts
-        // from nowhere. Saying where focus goes is cheaper than depending on which
-        // of the two paths ran.
-        // Back to the chip that asked, whichever way it was closed. The layer's
-        // own scope restores focus after a choice; a dismissal would otherwise
-        // leave the keyboard on a node that is no longer mounted.
-        onClose: () => app.focus.focus(options.anchorId),
-    });
-}

package/dist/src/view/sessionhead.d.ts

@@ -1,41 +0,0 @@
-import type { BoxProps, RenderOutput } from '@textui/core';
-import type { SessionSummary } from '../ahp/types.js';
-/**
- * What this conversation *is*, at the top of it.
- *
- * The first thing in the transcript rather than a band above it, and that is
- * the whole design: a caption pinned outside the scrolling region costs a row
- * of the conversation on every screen for ever, so it has to earn each one -
- * which meant one line, which meant dropping most of what it is for. Scrolled
- * with the conversation it costs nothing after the first screen and can say
- * everything, the way the top of a printed letter does.
- *
- * The identifiers are the point. They are what gets pasted into a shell or a
- * bug report, they are exactly what does not fit anywhere else, and the
- * catalogue's detail pane - the only other place they appear - is a screen
- * away from the conversation they belong to.
- */
-export interface ChatSessionHeadProps extends BoxProps {
-    session: SessionSummary;
-    /** What the last turn ran on. A session has no model; each message has one. */
-    model?: string;
-    /** The chat uri, when the host has said which one this dispatches to. */
-    chat?: string | null;
-    /** The settings in force, by the host's own labels. */
-    settings?: {
-        label: string;
-        value: string;
-    }[];
-    /**
-     * Who else the host says is in this session.
-     *
-     * This client is in the list too - it adds itself on opening the view - so
-     * a session with nobody else in it has one entry and says nothing, which is
-     * the ordinary case.
-     */
-    present?: {
-        clientId: string;
-        displayName?: string;
-    }[];
-}
-export declare const ChatSessionHead: (props: ChatSessionHeadProps) => RenderOutput;

package/dist/src/view/sessionhead.js

@@ -1,60 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
-import { defineComponent, useTheme } from '@textui/core';
-import { Column, KeyValue, Row } from '@textui/widgets';
-import { decodeStatus } from '../ahp/status.js';
-import { branchName } from '../state.js';
-/**
- * A timestamp a person can read, in whatever this machine calls a date.
- *
- * The host sends ISO, which is unambiguous and not what anybody wants to read
- * off a caption. An unparseable one is passed through rather than shown as
- * "Invalid Date": what the host said is more useful than what we made of it.
- */
-function when(iso) {
-    if (!iso)
-        return '';
-    const at = new Date(iso);
-    if (Number.isNaN(at.getTime()))
-        return iso;
-    return at.toLocaleString(undefined, {
-        year: 'numeric', month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit',
-    });
-}
-export const ChatSessionHead = defineComponent('ChatSessionHead', (props) => {
-    const { session, model, chat, settings = [], present = [], ...rest } = props;
-    const theme = useTheme();
-    const status = decodeStatus(session.status);
-    const started = when(session.createdAt);
-    const updated = when(session.modifiedAt);
-    // Only what is known. A row of empty values is what building this from a
-    // fixed list produces, and it reads as a session the host would not talk
-    // about rather than as one nobody has asked yet.
-    const rows = [
-        { label: 'Harness', value: [session.provider, model].filter(Boolean).join(`  ${theme.glyphs.separator}  `) },
-        ...settings.filter((setting) => setting.value).map((setting) => ({ ...setting })),
-        { label: 'Workspace', value: session.workingDirectories.map((dir) => dir.replace(/^file:\/\//, '')).join(', ') },
-        // Only when the host says one. A blank branch row reads as a detached
-        // head rather than as a host that does not report branches.
-        ...(branchName(session) ? [{ label: 'Branch', value: branchName(session) }] : []),
-        {
-            label: 'Started',
-            value: started && updated && updated !== started
-                ? `${started}  ${theme.glyphs.separator}  updated ${updated}`
-                : started,
-        },
-        // Last, and in full. A uri you can read half of is worse than one you
-        // cannot see at all: it looks like the whole thing.
-        { label: 'Session', value: session.resource },
-        ...(chat ? [{ label: 'Chat', value: chat }] : []),
-        // Only when somebody else is here. One entry is this client, and a row
-        // saying you are the person reading it is a row that tells nobody
-        // anything.
-        ...(present.length > 1
-            ? [{
-                    label: 'Here',
-                    value: present.map((one) => one.displayName ?? one.clientId).join(`  ${theme.glyphs.separator}  `),
-                }]
-            : []),
-    ].filter((row) => row.value !== '');
-    return (_jsxs(Column, { ...rest, gap: 0, children: [_jsxs(Row, { gap: 1, children: [_jsx("text", { content: theme.glyphs[status.glyph], fg: status.tone, shrink: 0 }), _jsx("text", { content: session.title, bold: true, wrap: "word", flex: 1 }), _jsx("text", { content: status.label, fg: status.tone, shrink: 0 })] }), _jsx(KeyValue, { items: rows })] }));
-});

package/dist/src/view/sessions.d.ts

@@ -1,34 +0,0 @@
-import type { BoxProps, RenderOutput } from '@textui/core';
-import type { SessionSummary } from '../ahp/types.js';
-/**
- * The catalogue.
- *
- * Still a `List` - the selection, the keys, the window and the highlight are
- * all the list's, and reimplementing them here is what the transcript already
- * proved is a mistake. What is ours is the row, because a session does not fit
- * the one-line shape a list gives you for free.
- *
- * It takes two lines, and the first one is why. A title, a harness, a
- * workspace and a status sharing a pane that is also sharing the terminal
- * with the detail panel leaves every one of them truncated:
- * `Draft replies for desk-produ…` beside `1b444e78-d050-4fb5-a5…` names
- * neither the conversation nor the directory it is in. So the title gets the
- * width, and everything that qualifies it goes underneath.
- */
-export interface SessionListProps extends BoxProps {
-    sessions: SessionSummary[];
-    selectedId?: string | null;
-    onSelect?(uri: string): void;
-    onOpen?(uri: string): void;
-    emptyMessage?: string;
-    focusId?: string;
-    autoFocus?: boolean;
-}
-export declare const SessionList: (props: SessionListProps) => RenderOutput;
-export interface ConnectionBadgeProps extends BoxProps {
-    url: string;
-    state: 'connecting' | 'connected' | 'offline';
-    sessions?: number;
-}
-/** Which host, and whether it is answering. */
-export declare const ConnectionBadge: (props: ConnectionBadgeProps) => RenderOutput;

package/dist/src/view/sessions.js

@@ -1,61 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
-import { defineComponent, stringWidth, useTheme } from '@textui/core';
-import { Badge, Column, List, Marquee, Row } from '@textui/widgets';
-import { decodeStatus } from '../ahp/status.js';
-import { branchName, projectName } from '../state.js';
-export const SessionList = defineComponent('SessionList', (props) => {
-    const { sessions, selectedId, onSelect, onOpen, emptyMessage, focusId, autoFocus, ...rest } = props;
-    const theme = useTheme();
-    const dot = `  ${theme.glyphs.separator}  `;
-    const items = sessions.map((session) => {
-        const status = decodeStatus(session.status);
-        const changes = session.changes;
-        return {
-            id: session.resource,
-            // Glyph first, so the one that wants a person is findable in a piped
-            // log, a 16-colour session and by a reader who cannot see the colour.
-            icon: theme.glyphs[status.glyph],
-            label: session.title,
-            // The second line, in the order it gets read: which harness, then
-            // where, then what it has to show for it.
-            //
-            // The harness stands where a model would. The catalogue does not carry
-            // one: `listSessions` answers with a `SessionSummary`, and the model
-            // AHP knows is the one on the *last message*, which lives on the
-            // session channel. A model per row would be a subscription per row.
-            description: [
-                session.provider,
-                // The project, then the branch it is on - a catalogue spanning
-                // several repositories is read by which one each row is in, and a
-                // list of them all on `main` is a list that needs opening to tell
-                // apart.
-                [projectName(session), branchName(session)].filter(Boolean).join(' '),
-                changes?.files
-                    ? `${changes.files} files  +${changes.additions ?? 0} -${changes.deletions ?? 0}`
-                    : '',
-                // What the host says it is doing, in its own words. Last, because it
-                // is the one that is usually not there.
-                session.activity ?? '',
-                // Why it is here at all, when nobody started it. Without this a
-                // session that appeared at nine in the morning is a row with no
-                // account of itself, sitting among rows somebody typed.
-                session.origin?.kind === 'automation' ? 'by an automation' : '',
-                status.archived ? 'archived' : '',
-            ].filter(Boolean).join(dot),
-            meta: status.label,
-            tone: status.tone,
-        };
-    });
-    return (_jsx(List, { items: items, itemHeight: 2, renderItem: (item, state) => (_jsxs(Column, { children: [_jsxs(Row, { gap: 1, children: [_jsx("text", { content: item.icon ?? '', ...(state.selected ? {} : { fg: item.tone }), shrink: 0 }), _jsx(Marquee, { content: item.label, active: state.selected && state.focused, flex: 1 }), _jsx("text", { content: item.meta ?? '', ...(state.selected ? {} : { fg: 'muted' }), shrink: 0 })] }), _jsxs(Row, { children: [_jsx("text", { content: ' '.repeat(stringWidth(item.icon ?? '') + 1), shrink: 0 }), _jsx(Marquee, { content: item.description ?? '', active: state.selected && state.focused, ...(state.selected ? {} : { fg: 'muted' }), flex: 1 })] })] })), ...(selectedId ? { selectedId } : {}), emptyMessage: emptyMessage ?? 'No sessions on this host', onSelect: (id) => onSelect?.(id), onActivate: (id) => onOpen?.(id), ...(focusId ? { focusId } : {}), ...(autoFocus ? { autoFocus: true } : {}), ...rest }));
-});
-/** Which host, and whether it is answering. */
-export const ConnectionBadge = defineComponent('ConnectionBadge', (props) => {
-    const { url, state, sessions, ...rest } = props;
-    const theme = useTheme();
-    const look = {
-        connected: { tone: 'success', glyph: theme.glyphs.bulletFilled },
-        connecting: { tone: 'warning', glyph: theme.glyphs.bulletHalf },
-        offline: { tone: 'danger', glyph: theme.glyphs.cross },
-    }[state];
-    return (_jsxs(Row, { gap: 1, ...rest, children: [_jsx("text", { content: look.glyph, fg: look.tone }), _jsx("text", { content: url, fg: "muted", truncate: "start" }), sessions !== undefined ? _jsx(Badge, { label: `${sessions} sessions`, tone: "muted" }) : null] }));
-});

package/dist/src/view/toolcall.d.ts

@@ -1,27 +0,0 @@
-import type { BoxProps, RenderOutput } from '@textui/core';
-import type { ToolCall } from '../ahp/types.js';
-/**
- * A tool call, as a row.
- *
- * Twenty of these in a turn look identical unless the *command* is on the row,
- * so the input is the row and the display name is a prefix. What it meant to
- * do is markdown, like everything else a host writes for a person; what came
- * back is not, and is shown as it arrived.
- *
- * The status is a glyph and a colour together. A 16-colour session, a piped
- * log and a colourblind reader all lose the colour and keep the glyph.
- *
- * It sits at the turn's own left edge rather than inside the gutter, with its
- * status glyph where the header's bullet is. A tool call is something the
- * agent *did*; indenting it inside the rule filed it under what the agent was
- * saying, which is the one thing it is not.
- */
-export interface ToolCallRowProps extends BoxProps {
-    call: ToolCall;
-    expanded?: boolean;
-    /** The transcript's cursor is on this row. */
-    active?: boolean;
-    /** Clicking the row opens it. */
-    onToggle?(): void;
-}
-export declare const ToolCallRow: (props: ToolCallRowProps) => RenderOutput;

package/dist/src/view/toolcall.js

@@ -1,48 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
-import { defineComponent, useTheme } from '@textui/core';
-import { Badge, Column, MarkdownView, Row } from '@textui/widgets';
-const LOOK = {
-    pending: { tone: 'muted', glyph: 'bulletHollow' },
-    'pending-confirmation': { tone: 'warning', glyph: 'bulletHalf' },
-    running: { tone: 'accent', glyph: 'bulletFilled' },
-    completed: { tone: 'success', glyph: 'check' },
-    failed: { tone: 'danger', glyph: 'cross' },
-    cancelled: { tone: 'muted', glyph: 'cross' },
-};
-/**
- * The input, as one line.
- *
- * A tool's arguments are often JSON, and JSON arrives with newlines in it. Put
- * straight on the row, a three-line object makes the row three lines tall and
- * every other cell in it vertically centred - so the name floats beside the
- * middle line of a brace-delimited block. The whole thing is on its own lines
- * once the row is opened; this is the part that fits beside a name.
- */
-function oneLine(text) {
-    return text.replace(/\s+/g, ' ').trim();
-}
-export const ToolCallRow = defineComponent('ToolCallRow', (props) => {
-    const { call, expanded, active, onToggle, ...rest } = props;
-    const theme = useTheme();
-    const look = LOOK[call.status] ?? { tone: 'muted', glyph: 'bulletHollow' };
-    const glyph = theme.glyphs[look.glyph];
-    const chevron = expanded ? theme.glyphs.chevronDown : theme.glyphs.chevronRight;
-    const failed = call.status === 'failed' || (call.exitCode !== undefined && call.exitCode !== 0);
-    const summary = oneLine(call.input ?? call.intention ?? '');
-    // Only when there is something under it. A chevron on a row that opens on
-    // to nothing is a promise the row cannot keep.
-    const opens = Boolean(call.intention ?? call.input ?? call.output ?? call.outcome
-        ?? (call.files && call.files.length > 0));
-    return (_jsxs(Column, { ...rest, ...(active ? { bg: 'selected' } : {}), children: [_jsxs(Row, { gap: 1, ...(opens && onToggle ? { onClick: onToggle } : {}), 
-                // The whole row lights up, not the glyph the pointer happens to be
-                // over: the row is the thing that opens.
-                style: { hover: { bg: 'hover' } }, children: [_jsx("text", { content: glyph, fg: look.tone }), _jsx("text", { content: call.name, bold: true }), _jsx("text", { content: summary, fg: "muted", flex: 1, truncate: "middle" }), call.status === 'pending-confirmation' ? _jsx(Badge, { label: "asks", tone: "warning", icon: theme.glyphs.warning }) : null, failed ? _jsx(Badge, { label: `exit ${call.exitCode ?? 1}`, tone: "danger" }) : null, opens ? _jsx("text", { content: chevron, fg: "subtle" }) : null] }), expanded ? (
-            // Indented to the row's own text, which starts one glyph and one gap
-            // in - so what opened out of a row lines up under it.
-            _jsxs(Column, { padding: [0, 0, 0, 2], gap: 0, children: [call.intention && call.intention !== call.name && call.intention !== call.input
-                        ? _jsx(MarkdownView, { content: call.intention, quiet: true })
-                        : null, call.input ? (
-                    // On its own lines, wrapped as written. This is where the JSON
-                    // goes: whole, and not sharing a row with the name.
-                    _jsx(Column, { bg: "surfaceAlt", padding: [0, 1], children: call.input.split('\n').map((line, i) => (_jsx("text", { content: line, fg: "text", wrap: "word" }, i))) })) : null, call.output ? (_jsxs(Column, { children: [call.output.split('\n').slice(0, 12).map((line, i) => (_jsx("text", { content: line, fg: "muted", truncate: "end" }, i))), call.output.split('\n').length > 12 ? (_jsx("text", { content: `${theme.glyphs.ellipsis} ${call.output.split('\n').length - 12} more lines`, fg: "subtle" })) : null] })) : null, call.files && call.files.length > 0 ? (_jsx(Column, { children: call.files.map((file) => (_jsx("text", { content: `${theme.glyphs.chevronRight} ${file}`, fg: "info" }, file))) })) : null, call.outcome ? _jsx("text", { content: call.outcome, fg: "subtle" }) : null] })) : null] }));
-});

package/dist/src/view/transcript.d.ts

@@ -1,50 +0,0 @@
-import type { BoxProps, RenderOutput } from '@textui/core';
-import type { Block } from '../blocks.js';
-/**
- * The conversation, as blocks in a feed.
- *
- * There is no scrolling in this file. `Feed` owns the viewport, the cursor and
- * the tail it follows, because none of that is about chat: a transcript, an
- * activity stream and a list of search results with snippets are the same
- * problem, which is "entries that are not one line tall". What is left here is
- * the only part that *is* about chat - which block draws as what.
- */
-export interface ChatTranscriptProps extends BoxProps {
-    blocks: Block[];
-    expanded: Record<string, boolean>;
-    onToggle(id: string): void;
-    /** Which block the cursor is on. Held by the screen, like every other state. */
-    cursor?: number;
-    onCursor?(index: number): void;
-    /**
-     * What the find box is looking for.
-     *
-     * Passed down to be coloured where it appears, not to decide what is drawn:
-     * every block stays where it was and the ones holding the term light up, so
-     * a reader keeps the conversation around a hit instead of a filtered list
-     * of the lines that matched.
-     */
-    match?: string;
-    /**
-     * Keep the cursor in view rather than only when it moves.
-     *
-     * For the find box, which drives the cursor: its first hit is often the
-     * block the cursor is already on, and a feed that only scrolls on a change
-     * would leave that one off screen while the box counted it.
-     */
-    pinCursor?: boolean;
-    /**
-     * What this conversation is, as the first thing in it.
-     *
-     * Inside the scrolling region rather than pinned above it: a caption outside
-     * costs a row of the conversation on every screen for ever, so it has to
-     * earn each one - which is what forces it down to a line and then down to
-     * less than it was for. Here it costs nothing after the first screen.
-     *
-     * It is not a block. The cursor walks the conversation and there is nothing
-     * to do to a caption, so it sits ahead of the indices rather than in them.
-     */
-    head?: RenderOutput;
-    focusId?: string;
-}
-export declare const ChatTranscript: (props: ChatTranscriptProps) => RenderOutput;

package/dist/src/view/transcript.js

@@ -1,60 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@textui/core/jsx-runtime";
-import { defineComponent, useTheme } from '@textui/core';
-import { Feed, Row } from '@textui/widgets';
-import { ChatBubble, Gutter, ReasoningBlock, StreamingText } from './bubble.js';
-import { ToolCallRow } from './toolcall.js';
-export const ChatTranscript = defineComponent('ChatTranscript', (props) => {
-    const { blocks, expanded, onToggle, cursor, onCursor, head, match, pinCursor, focusId = 'chat.transcript', ...rest } = props;
-    // The caption is an entry the feed scrolls and the cursor does not visit,
-    // so every index the feed reports is one further along than the block it
-    // stands for. Converted here, once, rather than at each of the three
-    // places that would otherwise each have to remember.
-    const lead = head ? 1 : 0;
-    return (_jsxs(Feed, { focusId: focusId, 
-        // Page up from the composer means the conversation above it. There is
-        // nothing else on this screen those keys could be for, and taking the
-        // keyboard off the field to use them is what a reader is avoiding.
-        pageKeys: "always", ...(cursor !== undefined ? { selectedIndex: cursor + lead } : {}), ...(pinCursor ? { pinSelection: true } : {}), ...(onCursor ? { onSelect: (index) => onCursor(Math.max(0, index - lead)) } : {}), onActivate: (index) => {
-            const block = blocks[index - lead];
-            if (block)
-                onToggle(block.id);
-        }, ...rest, children: [head ?? null, blocks.map((block) => (_jsx(BlockView, { block: block, expanded: expanded[block.id] ?? false, active: cursor !== undefined && blocks[cursor]?.id === block.id, ...(match ? { match } : {}), onToggle: () => onToggle(block.id) }, block.id)))] }));
-});
-const BlockView = defineComponent('ChatBlockView', ({ block, expanded, active, match, onToggle }) => {
-    const theme = useTheme();
-    // Spread rather than passed, so a block with no search over it carries no
-    // extra prop and its text node is compared unchanged.
-    const hit = match ? { match } : {};
-    switch (block.kind) {
-        case 'said':
-            // The blank row is the turn boundary. A uniform gap between every block
-            // would space a paragraph from the sentence it belongs to just as much
-            // as it spaces one speaker from the next.
-            return (_jsx(ChatBubble, { speaker: "user", padding: [1, 0, 0, 0], children: _jsx("text", { content: block.text, wrap: "word", ...hit }) }));
-        case 'header':
-            return (_jsxs(Row, { gap: 1, padding: [1, 0, 0, 0], children: [_jsx("text", { content: theme.glyphs.bulletFilled, fg: block.state === 'running' ? 'accent' : 'muted' }), _jsx("text", { content: block.model ?? 'agent', bold: true, fg: "accent" }), block.settings ? _jsx("text", { content: block.settings, fg: "subtle" }) : null, _jsx("text", { content: block.meta, fg: "subtle", flex: 1 }), block.state === 'cancelled' ? _jsx("text", { content: "stopped", fg: "warning" }) : null, block.state === 'failed' ? _jsx("text", { content: "failed", fg: "danger" }) : null] }));
-        case 'prose':
-            return (_jsxs(Row, { gap: 1, children: [_jsx(Gutter, {}), _jsx(StreamingText, { content: block.content, streaming: block.streaming, flex: 1, ...hit })] }));
-        case 'reasoning':
-            return (_jsxs(Row, { gap: 1, children: [_jsx(Gutter, {}), _jsx(ReasoningBlock, { content: block.content, expanded: expanded, streaming: block.streaming, flex: 1, ...hit, ...(active ? { bg: 'selected' } : {}) })] }));
-        case 'notice':
-            return (_jsxs(Row, { gap: 1, children: [_jsx("text", { content: theme.glyphs.info, fg: "info" }), _jsx("text", { content: block.content, fg: "muted", wrap: "word", flex: 1, ...hit })] }));
-        // Not a notice. A notice is the harness saying something in passing, and
-        // this is the turn stopping - so it takes the danger tone and says whether
-        // there is anything to carry on from.
-        case 'failure':
-            return (_jsxs(Row, { gap: 1, children: [_jsx("text", { content: theme.glyphs.cross, fg: "danger" }), _jsx("text", { content: block.content, fg: "danger", wrap: "word", flex: 1, ...hit }), block.resumable ? _jsx("text", { content: "resumable", fg: "subtle" }) : null] }));
-        case 'tool':
-            // No gutter. A tool call is something the agent *did*, not something it
-            // said, so it sits at the turn's own left edge with a status glyph where
-            // the header's bullet is - rather than indented inside the rule as
-            // though it were a paragraph of the answer.
-            return _jsx(ToolCallRow, { call: block.call, expanded: expanded, active: active, onToggle: onToggle });
-        case 'queued':
-            // Not sent. It reads as a message unless it says so, and "I typed that
-            // and nothing happened" is the complaint that follows.
-            return (_jsxs(Row, { gap: 1, children: [_jsx("text", { content: theme.glyphs.chevronRight, fg: active ? 'accent' : 'subtle' }), _jsx("text", { content: block.text, fg: "subtle", italic: true, wrap: "word", flex: 1, ...hit }), _jsx("text", { content: active ? 'enter drops it' : 'queued', fg: "warning" })] }));
-        default:
-            return null;
-    }
-});