@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.0

package/lib/types/components/messages/TranscriptLeaves.d.ts

@@ -0,0 +1,85 @@
+import React from 'react';
+import type { Theme } from '../../theme.js';
+import type { ClickEvent } from '../../ink/events/click-event.js';
+import type { ToolRow } from '../../dsh-adapter/channel.js';
+import type { ToolBackground } from '../../tuiDisplayPrefs.js';
+import type { TranscriptImage } from '../../dsh-adapter/transcript-images.js';
+import type { AgentMessageState, AgentMessageVia, AgentMessageView } from './agentTeam.js';
+/** Delivery-state badge color: only what the channel reported — green is
+ *  reserved for an explicit `delivered` fact, dim for `unknown`/`expired`. */
+export declare function agentMessageStateColor(state: AgentMessageState): keyof Theme;
+/** The localized state word (issued/queued/delivered/held/refused/expired/
+ *  unknown) — one vocabulary across composer status lines and flow rows. */
+export declare function agentMessageStateText(state: AgentMessageState): string;
+/** One endpoint's short label: `user`/`parent`/`child` for the relations the
+ *  view itself proves (own id, parentSessionId), the stable short id for any
+ *  other agent. Absent ids stay unnamed — the caller decides whether that is
+ *  an unknown-relation row (no arrow). */
+export declare function agentMessagePartyLabel(id: string | undefined, selfAgentId: string, parentSessionId?: string): string | undefined;
+/** The localized transport word. */
+export declare function agentMessageViaText(via: AgentMessageVia): string;
+/**
+ * One agent↔agent message as a transcript leaf: a `⇄ from → to · state`
+ * header plus an indented preview, paged together with the thinking/text/
+ * tool leaves. Without both endpoints it shows the unknown-relation line
+ * and no arrow.
+ */
+export declare function AgentMessageLeafRow({ message, selfAgentId, marginTopOnTurn }: {
+    message: AgentMessageView;
+    /** This child's agent id — resolves `child` in the party labels. */
+    selfAgentId: string;
+    marginTopOnTurn: boolean;
+}): React.ReactNode;
+/**
+ * Transcript leaf rows: the main MessageList and the subagent transcript
+ * pages render thinking / tool / text rows through these thin adapters, so
+ * a child transcript reads like the main one. Presentation only: fold
+ * state, reveal cursors and row anchoring stay with the callers.
+ */
+/** A settled/live thinking row (`⚓ Thinking` preview or expanded body). */
+export declare function ThinkingLeafRow({ thinking, textFull, marginTopOnTurn, streaming, preview, verbose, durationMs, reasoningTokens, isSelected, onClick, }: {
+    thinking: string;
+    /** The full un-revealed text the live preview ticker follows. */
+    textFull?: string;
+    marginTopOnTurn: boolean;
+    streaming?: boolean;
+    preview?: boolean;
+    verbose: boolean;
+    durationMs?: number;
+    /** Thinking reported only as a count (no body) — the one-line header. */
+    reasoningTokens?: number;
+    isSelected?: boolean;
+    onClick?(event: ClickEvent): void;
+}): React.ReactNode;
+/** A tool-call card (args / result / error / diff), optionally with images. */
+export declare function ToolLeafRow({ tool, marginTopOnTurn, verbose, isSelected, isExpanded, footnote, diffLayout, toolBackground, smoothReveal, fresh, revealVersion, foldTerminalCommand, onClick, onOpenFile, images, onPreviewImage, suppressImageGraphics, sourceFolded, fullscreen, }: {
+    tool: ToolRow;
+    marginTopOnTurn: boolean;
+    verbose: boolean;
+    isSelected?: boolean;
+    isExpanded?: boolean;
+    footnote?: string;
+    diffLayout?: 'auto' | 'split' | 'unified';
+    toolBackground?: ToolBackground;
+    smoothReveal?: boolean;
+    fresh?: boolean;
+    revealVersion?: number;
+    foldTerminalCommand?: boolean;
+    onClick?(event: ClickEvent): void;
+    onOpenFile?: (path: string) => void;
+    images?: readonly TranscriptImage[];
+    onPreviewImage?(image: TranscriptImage): void;
+    suppressImageGraphics?: boolean;
+    /** The transcript window folded this row's source (previews only). */
+    sourceFolded?: boolean;
+    /** Fullscreen layout (more live output lines on a running card). */
+    fullscreen?: boolean;
+}): React.ReactNode;
+/** An assistant text row (`●` bullet + markdown body). */
+export declare function AssistantTextLeafRow({ text, marginTopOnTurn, isSelected, isExpanded, }: {
+    text: string;
+    marginTopOnTurn: boolean;
+    isSelected?: boolean;
+    isExpanded?: boolean;
+}): React.ReactNode;
+//# sourceMappingURL=TranscriptLeaves.d.ts.map

package/lib/types/components/messages/TranscriptLeaves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TranscriptLeaves.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/TranscriptLeaves.tsx"],"names":[],"mappings":"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"}

package/lib/types/components/messages/TranscriptLeaves.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from '../../ui.js';
+import { t } from '../../i18n.js';
+import { AssistantTextMessage } from './AssistantTextMessage.js';
+import { AssistantThinkingMessage } from './AssistantThinkingMessage.js';
+import { AssistantToolUseMessage } from './AssistantToolUseMessage.js';
+import { TranscriptImages } from './TranscriptImages.js';
+// ── agent↔agent message flow leaves ─────────────────────────────────────────
+/** Delivery-state badge color: only what the channel reported — green is
+ *  reserved for an explicit `delivered` fact, dim for `unknown`/`expired`. */
+export function agentMessageStateColor(state) {
+    if (state === 'delivered')
+        return 'success';
+    if (state === 'refused')
+        return 'error';
+    if (state === 'issued' || state === 'queued' || state === 'held')
+        return 'warning';
+    return 'subtle';
+}
+/** The localized state word (issued/queued/delivered/held/refused/expired/
+ *  unknown) — one vocabulary across composer status lines and flow rows. */
+export function agentMessageStateText(state) {
+    return t(`agent-message-delivery-${state}`);
+}
+/** One endpoint's short label: `user`/`parent`/`child` for the relations the
+ *  view itself proves (own id, parentSessionId), the stable short id for any
+ *  other agent. Absent ids stay unnamed — the caller decides whether that is
+ *  an unknown-relation row (no arrow). */
+export function agentMessagePartyLabel(id, selfAgentId, parentSessionId) {
+    if (id === undefined)
+        return undefined;
+    if (id === 'user')
+        return t('agent-message-source-user');
+    if (id === selfAgentId)
+        return t('agent-message-source-child');
+    if (parentSessionId !== undefined && id === parentSessionId)
+        return t('agent-message-source-parent');
+    return id.length > 8 ? id.slice(0, 8) : id;
+}
+/** The localized transport word. */
+export function agentMessageViaText(via) {
+    return t(`agent-message-via-${via}`);
+}
+/**
+ * One agent↔agent message as a transcript leaf: a `⇄ from → to · state`
+ * header plus an indented preview, paged together with the thinking/text/
+ * tool leaves. Without both endpoints it shows the unknown-relation line
+ * and no arrow.
+ */
+export function AgentMessageLeafRow({ message, selfAgentId, marginTopOnTurn }) {
+    const from = agentMessagePartyLabel(message.from, selfAgentId, message.parentSessionId);
+    const to = agentMessagePartyLabel(message.to, selfAgentId, message.parentSessionId);
+    const known = from !== undefined && to !== undefined;
+    const stateColor = agentMessageStateColor(message.state);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: marginTopOnTurn ? 1 : 0, paddingLeft: 2, children: [_jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(Text, { color: "accent", children: "\u21C4" }), known ? (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: t('agent-message-from-to', { from, to }) })) : (_jsx(Text, { dimColor: true, italic: true, wrap: "truncate-end", children: t('agent-message-unknown-target') })), _jsx(Text, { dimColor: true, children: "\u00B7" }), _jsx(Box, { flexShrink: 0, children: _jsx(Text, { color: stateColor, children: agentMessageStateText(message.state) }) }), _jsx(Text, { dimColor: true, children: "\u00B7" }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: agentMessageViaText(message.via) })] }), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: message.text }) }), message.state === 'unknown' && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, italic: true, children: t('agent-message-no-delivery-fact') }) }))] }));
+}
+/**
+ * Transcript leaf rows: the main MessageList and the subagent transcript
+ * pages render thinking / tool / text rows through these thin adapters, so
+ * a child transcript reads like the main one. Presentation only: fold
+ * state, reveal cursors and row anchoring stay with the callers.
+ */
+/** A settled/live thinking row (`⚓ Thinking` preview or expanded body). */
+export function ThinkingLeafRow({ thinking, textFull, marginTopOnTurn, streaming = false, preview = false, verbose, durationMs, reasoningTokens, isSelected = false, onClick, }) {
+    return (_jsx(AssistantThinkingMessage, { thinking: thinking, textFull: textFull, marginTopOnTurn: marginTopOnTurn, streaming: streaming, preview: preview, verbose: verbose, durationMs: durationMs, reasoningTokens: reasoningTokens, isSelected: isSelected, onClick: onClick }));
+}
+/** A tool-call card (args / result / error / diff), optionally with images. */
+export function ToolLeafRow({ tool, marginTopOnTurn, verbose, isSelected = false, isExpanded = false, footnote, diffLayout, toolBackground, smoothReveal, fresh, revealVersion, foldTerminalCommand, onClick, onOpenFile, images, onPreviewImage, suppressImageGraphics, sourceFolded, fullscreen, }) {
+    return (_jsxs(_Fragment, { children: [_jsx(AssistantToolUseMessage, { tool: tool, marginTopOnTurn: marginTopOnTurn, verbose: verbose, isSelected: isSelected, isExpanded: isExpanded, footnote: footnote, diffLayout: diffLayout, toolBackground: toolBackground, smoothReveal: smoothReveal, fresh: fresh, revealVersion: revealVersion, foldTerminalCommand: foldTerminalCommand, onClick: onClick, onOpenFile: onOpenFile, sourceFolded: sourceFolded, fullscreen: fullscreen }), images !== undefined && _jsx(TranscriptImages, { images: images, indent: 4, onPreview: onPreviewImage, suppressGraphics: suppressImageGraphics })] }));
+}
+/** An assistant text row (`●` bullet + markdown body). */
+export function AssistantTextLeafRow({ text, marginTopOnTurn, isSelected = false, isExpanded = false, }) {
+    return (_jsx(AssistantTextMessage, { text: text, marginTopOnTurn: marginTopOnTurn, isSelected: isSelected, isExpanded: isExpanded }));
+}

package/lib/types/components/messages/agentTeam.d.ts

@@ -0,0 +1,69 @@
+/**
+ * UI-side agent-team helpers. The message domain types live in the channel
+ * port (`adapter/ports/channel-view.ts`) and are re-exported for the UI;
+ * this module adds the Agent View source stack, compose-target resolution
+ * and the parent/sibling math of the workbench.
+ */
+import type { SubagentState } from '../../dsh-adapter/subagents.js';
+export type { AgentIdentity, AgentMessageControl, AgentMessageState, AgentMessageSubmitInput, AgentMessageSubmitResult, AgentMessageView, AgentMessageVia, } from '../../adapter/ports/channel-view.js';
+/** Where the Agent View was opened from, i.e. where Esc returns to. The optional
+ *  `panel` mark says the entry came from the side-panel agents surface, so
+ *  the exit returns to the panel (route preserved) instead of the fullscreen
+ *  form of the same screen. */
+export type AgentViewSource = {
+    readonly kind: 'chat';
+    readonly returnFocus: 'prompt' | 'transcript';
+} | {
+    readonly kind: 'agents-dashboard';
+    readonly panel?: true;
+} | {
+    readonly kind: 'agent-detail';
+    readonly agentId: string;
+    readonly panel?: true;
+} | {
+    readonly kind: 'transcript-card';
+    readonly rowId: number;
+};
+/** The composer's target, resolved from the roster: a unique name addresses
+ *  by name, a duplicated one by stable id (still submittable), and no name
+ *  at all has no submit, only the notice. */
+export interface AgentComposeTarget {
+    readonly agentId: string;
+    /** Unique across the roster → address by name. */
+    readonly name?: string;
+    /** The name is duplicated across agents → address by stable id. */
+    readonly ambiguous?: true;
+}
+/** Resolve a compose target from the roster's labels (the descriptions):
+ *  a unique label addresses by name, duplicates carry `ambiguous` (the
+ *  composer shows the stable id), no label at all stays nameless. */
+export declare function agentComposeTargetOf(agentId: string, labels: ReadonlyMap<string, string>): AgentComposeTarget;
+/** Who spawned an agent, only as far as the data proves it. 'main' = the
+ *  session's main loop (depth 1, the SDK's spawn-depth definition).
+ *  'agent' = a named parent agent. 'unknown' = depth >= 2 without a parent
+ *  id (old metadata): never folded into 'main' or into an agent at the
+ *  same depth. */
+export type AgentParentFact = {
+    readonly kind: 'main';
+} | {
+    readonly kind: 'agent';
+    readonly agentId: string;
+} | {
+    readonly kind: 'unknown';
+};
+/** The parent fact of one roster row from the roster's own fields. */
+export declare function agentParentFactOf(agent: Pick<SubagentState, 'parentAgentId' | 'depth'>): AgentParentFact;
+/** The parent fact of the VIEWED agent, letting the loaded transcript's
+ *  explicit parent override the roster's (the disk copy is the durable
+ *  truth; a still-loading or absent transcript keeps the roster fact).
+ *  transcriptParent follows SubagentTranscriptPage.parentAgentId: null =
+ *  depth-1-or-old-format, so it only proves 'main' together with depth 1. */
+export declare function viewedAgentParentFact(agent: SubagentState, transcriptParent: string | null | undefined): AgentParentFact;
+/** The switchable neighbourhood of the viewed agent: its parent and its
+ *  siblings, i.e. roster agents with the same known parent. The same depth
+ *  alone never makes siblings; an unknown parent yields none. */
+export declare function agentNeighbourhood(self: SubagentState, roster: readonly SubagentState[], transcriptParent: string | null | undefined): {
+    readonly parent: AgentParentFact;
+    readonly siblings: readonly SubagentState[];
+};
+//# sourceMappingURL=agentTeam.d.ts.map

package/lib/types/components/messages/agentTeam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentTeam.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/agentTeam.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAEnE,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,gBAAgB,EAChB,eAAe,GAChB,MAAM,qCAAqC,CAAA;AAE5C;;;+BAG+B;AAC/B,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,GAAG,YAAY,CAAA;CAAE,GACxE;IAAE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,CAAA;CAAE,GAC5D;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,CAAA;CAAE,GAClF;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhE;;6CAE6C;AAC7C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,kDAAkD;IAClD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,mEAAmE;IACnE,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAA;CAC1B;AAED;;qEAEqE;AACrE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,kBAAkB,CAM7G;AAID;;;;kBAIkB;AAClB,MAAM,MAAM,eAAe,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAE7I,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,eAAe,CAIxG;AAED;;;;6EAI6E;AAC7E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,CAIxH;AAED;;iEAEiE;AACjE,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC1C;IAAE,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAA;CAAE,CAenF"}

package/lib/types/components/messages/agentTeam.js

@@ -0,0 +1,53 @@
+/** Resolve a compose target from the roster's labels (the descriptions):
+ *  a unique label addresses by name, duplicates carry `ambiguous` (the
+ *  composer shows the stable id), no label at all stays nameless. */
+export function agentComposeTargetOf(agentId, labels) {
+    const name = labels.get(agentId);
+    if (name === undefined || name === '')
+        return { agentId };
+    let duplicates = 0;
+    for (const other of labels.values())
+        if (other === name)
+            duplicates += 1;
+    return duplicates > 1 ? { agentId, name, ambiguous: true } : { agentId, name };
+}
+/** The parent fact of one roster row from the roster's own fields. */
+export function agentParentFactOf(agent) {
+    if (agent.parentAgentId !== undefined)
+        return { kind: 'agent', agentId: agent.parentAgentId };
+    if (agent.depth === 1)
+        return { kind: 'main' };
+    return { kind: 'unknown' };
+}
+/** The parent fact of the VIEWED agent, letting the loaded transcript's
+ *  explicit parent override the roster's (the disk copy is the durable
+ *  truth; a still-loading or absent transcript keeps the roster fact).
+ *  transcriptParent follows SubagentTranscriptPage.parentAgentId: null =
+ *  depth-1-or-old-format, so it only proves 'main' together with depth 1. */
+export function viewedAgentParentFact(agent, transcriptParent) {
+    if (transcriptParent !== undefined && transcriptParent !== null)
+        return { kind: 'agent', agentId: transcriptParent };
+    if (transcriptParent === null && agent.depth === 1)
+        return { kind: 'main' };
+    return agentParentFactOf(agent);
+}
+/** The switchable neighbourhood of the viewed agent: its parent and its
+ *  siblings, i.e. roster agents with the same known parent. The same depth
+ *  alone never makes siblings; an unknown parent yields none. */
+export function agentNeighbourhood(self, roster, transcriptParent) {
+    const parent = viewedAgentParentFact(self, transcriptParent);
+    const parentOf = (other) => agentParentFactOf(other);
+    const sameParent = (other) => {
+        if (parent.kind === 'main')
+            return parentOf(other).kind === 'main';
+        if (parent.kind === 'agent') {
+            const otherParent = parentOf(other);
+            return otherParent.kind === 'agent' && otherParent.agentId === parent.agentId;
+        }
+        return false;
+    };
+    const siblings = parent.kind === 'unknown'
+        ? []
+        : roster.filter(other => other.agentId !== self.agentId && sameParent(other));
+    return { parent, siblings };
+}

package/lib/types/components/messages/liveOutputLines.d.ts

@@ -0,0 +1,33 @@
+/** Live lines a running card shows inline. */
+export declare const LIVE_OUTPUT_LINES_INLINE = 5;
+/** Live lines a running card shows in fullscreen. */
+export declare const LIVE_OUTPUT_LINES_FULLSCREEN = 8;
+/** How many live lines a card shows: the whole retained tail when
+ *  verbose (Ctrl+O / expanded), else 5 inline and 8 in fullscreen. */
+export declare function liveOutputMaxLines(verbose: boolean, fullscreen: boolean): number;
+/** What the card renders of a live tail. */
+export interface LiveOutputView {
+    /** Older lines not shown (dropped by the tail bound, or retained but
+     *  above the shown window). */
+    readonly omitted: number;
+    /** The newest lines, oldest first, each one terminal row. */
+    readonly lines: readonly string[];
+}
+/** One raw output line as the card may paint it (uncut). */
+export declare function cleanOutputLine(raw: string): string;
+/** Cut a clean line to `width` cells, marking a cut with `…`. */
+export declare function fitOutputLine(line: string, width: number): string;
+/**
+ * Rows the live block of a card paints (the omitted header plus the shown
+ * lines): the card's height input for the transcript's layout signature.
+ * Scans back at most `maxLines + 1` line breaks, so it stays cheap per
+ * frame however long the tail is.
+ */
+export declare function liveOutputRows(text: string | undefined, dropped: number, maxLines: number): number;
+/**
+ * The newest `maxLines` lines of a tail, cleaned and fitted to `width`
+ * cells, with the count of older lines (`dropped` = lines the tail bound
+ * already discarded).
+ */
+export declare function liveOutputView(text: string, dropped: number, maxLines: number, width: number): LiveOutputView;
+//# sourceMappingURL=liveOutputLines.d.ts.map

package/lib/types/components/messages/liveOutputLines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveOutputLines.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/liveOutputLines.ts"],"names":[],"mappings":"AAoBA,8CAA8C;AAC9C,eAAO,MAAM,wBAAwB,IAAI,CAAA;AACzC,qDAAqD;AACrD,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C;sEACsE;AACtE,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,CAGhF;AAED,4CAA4C;AAC5C,MAAM,WAAW,cAAc;IAC7B;mCAC+B;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;CAClC;AAID,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMnD;AAED,iEAAiE;AACjE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAOjE;AAUD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAclG;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,CAY7G"}

package/lib/types/components/messages/liveOutputLines.js

@@ -0,0 +1,100 @@
+/**
+ * The running card's view of a tool's live output (`ToolRow.liveOutput`,
+ * N4): the newest few lines of the bounded tail, sanitized and cut to the
+ * card's width in terminal cells, plus how many older lines are not shown.
+ *
+ * Only the shown lines are touched: the tail is scanned backwards for its
+ * last line breaks, never split whole, so the per-render cost does not
+ * grow with the tail. Each shown line is sanitized for the render path:
+ *
+ *  - a carriage return rewrites its line (progress bars): the line shows
+ *    its last state, the text after the final `\r`;
+ *  - ANSI escape sequences (colours, cursor moves, OSC links) and every
+ *    other control character are removed; tabs become spaces;
+ *  - the line is cut to the width budget in display cells (CJK and emoji
+ *    count double) with a trailing `…`, so one row never wraps.
+ */
+import stripAnsi from 'strip-ansi';
+import { LIVE_OUTPUT_MAX_LINES } from '../../channel/live-output.js';
+import { truncateToWidth } from '../../ink/truncateToWidth.js';
+/** Live lines a running card shows inline. */
+export const LIVE_OUTPUT_LINES_INLINE = 5;
+/** Live lines a running card shows in fullscreen. */
+export const LIVE_OUTPUT_LINES_FULLSCREEN = 8;
+/** How many live lines a card shows: the whole retained tail when
+ *  verbose (Ctrl+O / expanded), else 5 inline and 8 in fullscreen. */
+export function liveOutputMaxLines(verbose, fullscreen) {
+    if (verbose)
+        return LIVE_OUTPUT_MAX_LINES;
+    return fullscreen ? LIVE_OUTPUT_LINES_FULLSCREEN : LIVE_OUTPUT_LINES_INLINE;
+}
+const TAB = '    ';
+/** One raw output line as the card may paint it (uncut). */
+export function cleanOutputLine(raw) {
+    let line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+    const carriage = line.lastIndexOf('\r');
+    if (carriage !== -1)
+        line = line.slice(carriage + 1);
+    // eslint-disable-next-line no-control-regex -- deliberate: untrusted process output on the render path
+    return stripAnsi(line).replace(/\t/gu, TAB).replace(/[\u0000-\u0008\u000a-\u001f\u007f-\u009f]/gu, '');
+}
+/** Cut a clean line to `width` cells, marking a cut with `…`. */
+export function fitOutputLine(line, width) {
+    const budget = Math.max(1, width);
+    // truncateToWidth walks code points only until the budget is exceeded,
+    // so a 16 KiB line costs no more than a short one.
+    const head = truncateToWidth(line, budget);
+    if (head.length === line.length)
+        return line;
+    return `${truncateToWidth(head, budget - 1)}…`;
+}
+/** Lines in a tail (a trailing break closes the last line). */
+function lineCount(text) {
+    if (text === '')
+        return 0;
+    let breaks = 0;
+    for (let at = text.indexOf('\n'); at !== -1; at = text.indexOf('\n', at + 1))
+        breaks += 1;
+    return breaks + (text.endsWith('\n') ? 0 : 1);
+}
+/**
+ * Rows the live block of a card paints (the omitted header plus the shown
+ * lines): the card's height input for the transcript's layout signature.
+ * Scans back at most `maxLines + 1` line breaks, so it stays cheap per
+ * frame however long the tail is.
+ */
+export function liveOutputRows(text, dropped, maxLines) {
+    if (text === undefined || text === '' || maxLines <= 0)
+        return 0;
+    let shown = 0;
+    let more = false;
+    let end = text.endsWith('\n') ? text.length - 1 : text.length;
+    while (end >= 0) {
+        if (shown === maxLines) {
+            more = true;
+            break;
+        }
+        shown += 1;
+        end = end === 0 ? -1 : text.lastIndexOf('\n', end - 1);
+    }
+    return shown + (more || dropped > 0 ? 1 : 0);
+}
+/**
+ * The newest `maxLines` lines of a tail, cleaned and fitted to `width`
+ * cells, with the count of older lines (`dropped` = lines the tail bound
+ * already discarded).
+ */
+export function liveOutputView(text, dropped, maxLines, width) {
+    if (text === '' || maxLines <= 0)
+        return { omitted: dropped + lineCount(text), lines: [] };
+    const newest = [];
+    let end = text.endsWith('\n') ? text.length - 1 : text.length;
+    while (end >= 0 && newest.length < maxLines) {
+        const brk = end === 0 ? -1 : text.lastIndexOf('\n', end - 1);
+        newest.push(text.slice(brk + 1, end));
+        end = brk;
+    }
+    newest.reverse();
+    const lines = newest.map(line => fitOutputLine(cleanOutputLine(line), width));
+    return { omitted: dropped + lineCount(text) - newest.length, lines };
+}

package/lib/types/components/messages/subagentTranscript.d.ts

@@ -0,0 +1,146 @@
+import type { SubagentOutputLine, SubagentState } from '../../dsh-adapter/subagents.js';
+import type { SubagentTranscriptView, ToolRow } from '../../adapter/ports/channel-view.js';
+import type { SubagentTranscriptWindow } from '../../agent/capabilities.js';
+import type { AgentEvent } from '../../agent/events.js';
+import type { AgentMessageView } from './agentTeam.js';
+/** One folded leaf of the child's transcript: thinking (a real body, or
+ *  the honest "body unavailable" marker a signature/count-only block
+ *  degrades to), text and tool cards — the vocabulary the shared leaf
+ *  renderers paint, so a child row reads exactly like a main one. */
+export type TranscriptLeaf = {
+    kind: 'thinking';
+    key: string;
+    text: string;
+} | {
+    kind: 'thinking-unavailable';
+    key: string;
+    tokens: number | undefined;
+} | {
+    kind: 'text';
+    key: string;
+    text: string;
+} | {
+    kind: 'tool';
+    key: string;
+    tool: ToolRow;
+} | {
+    kind: 'agent-message';
+    key: string;
+    message: AgentMessageView;
+};
+/** Presentations that never earn a duplicate card here either (the main
+ *  projector's rule): a nested delegation renders as the subagent card, a
+ *  todo write lives in the todo panel, a question in its dialog. */
+export declare const TRANSCRIPT_SUPPRESSED_CARDS: ReadonlySet<string>;
+/** Where one history page sits among the pages, for placing the agent
+ *  message feed: `olderPagesRemain` = the page is not the oldest one, so
+ *  messages observed before its first event belong to an older page;
+ *  `before` = the start of the newer page already folded (that page holds
+ *  the messages from there on). */
+export interface TranscriptPagePlacement {
+    readonly olderPagesRemain?: boolean;
+    readonly before?: number;
+    /** Collects the tool results whose call this page does not hold (the
+     *  call sits on an older page), keyed by call id. */
+    readonly orphans?: Map<string, ToolResultEvent>;
+}
+type ToolResultEvent = Extract<AgentEvent, {
+    type: 'tool.result';
+}>;
+/** Fold one history page's lane events into leaf rows (oldest first;
+ *  `into` may already hold the older pages' rows). A tool result whose
+ *  call is not on this page goes to `page.orphans` (or is dropped without
+ *  one) until the older page with the call is folded; consecutive blocks
+ *  of one API message join (the store splits a message into per-block
+ *  entries sharing the anchor).
+ *
+ *  `messages` (the agent↔agent feed for THIS child, newest last) is
+ *  interleaved by observedAt: each is flushed as an `agent-message` leaf
+ *  before the first event observed at/after it. Only the messages that
+ *  fall inside this page's span are placed (see TranscriptPagePlacement),
+ *  so loading an older page never repeats one. Returns the lower bound of
+ *  the span this page took — the `before` for the next older page. */
+export declare function foldTranscriptLeaves(events: readonly AgentEvent[], into: TranscriptLeaf[], messages?: readonly AgentMessageView[], page?: TranscriptPagePlacement): number;
+/** The transcript page's load state. `ready` keeps its rows while a newer
+ *  page reloads (settlement) and while an older window prepends. */
+export type TranscriptState = {
+    status: 'idle';
+} | {
+    status: 'loading';
+} | {
+    status: 'unavailable';
+} | ReadyTranscript;
+/** A loaded transcript. `messagesFrom` is where the placed agent messages
+ *  start (the next older page takes the ones before it); `orphanResults`
+ *  are results on the loaded pages whose call is on a page not loaded yet. */
+export interface ReadyTranscript {
+    readonly status: 'ready';
+    readonly agentId: string;
+    readonly leaves: TranscriptLeaf[];
+    readonly parentAgentId: string | null;
+    readonly hasOlder: boolean;
+    readonly skippedFromStart: number;
+    /** Native opaque paging cursor, when the source does not expose a count. */
+    readonly sourceCursor?: string;
+    readonly loadingOlder: boolean;
+    readonly messagesFrom: number;
+    readonly orphanResults: ReadonlyMap<string, ToolResultEvent>;
+}
+/** The newest page of a child's transcript, folded. */
+export declare function foldNewestPage(agentId: string, page: SubagentTranscriptView, messages: readonly AgentMessageView[]): ReadyTranscript;
+/** One older page folded in front of a loaded transcript: its agent
+ *  messages are the ones before the loaded span, and the results the newer
+ *  pages held for its calls settle those calls' cards. */
+export declare function foldOlderPage(current: ReadyTranscript, page: SubagentTranscriptView, messages: readonly AgentMessageView[]): ReadyTranscript;
+/** One load-older window (messages; matches the backend's newest page). */
+export declare const TRANSCRIPT_OLDER_CHUNK = 400;
+/** The retained output window both stores keep (channel/activity.ts and
+ *  dsh-adapter/subagents.ts): a tail at this size is a WINDOW, and the
+ *  output page says so when no transcript source can show the rest. */
+export declare const OUTPUT_WINDOW_CAP = 160;
+/** A live tail line as the transcript page renders it below the history. */
+export type LiveLeaf = {
+    kind: 'live';
+    line: SubagentOutputLine;
+};
+/** Render keys must be unique per row: the store's block-per-entry split can
+ *  repeat one anchor inside a page (a text, a tool and another text of one
+ *  message), so a repeated key gets an ordinal suffix; a leaf is never
+ *  dropped for its key. The first occurrence keeps its key, later ones are
+ *  copied. */
+export declare function uniqueRenderKeys(leaves: readonly TranscriptLeaf[]): TranscriptLeaf[];
+/** Prepend one older page's folded leaves. The store splits one API message
+ *  into per-block entries sharing the anchor, so a block can only be cut
+ *  across pages at the boundary: the older page's last leaf against the
+ *  current list's first. Those two merge when they share the key and the
+ *  text/thinking kind (the fold already joined everything consecutive
+ *  within a page). Every other leaf keeps its own row in the older page's
+ *  order: a different kind under the same key is kept, and a tool between
+ *  two text parts of one message stays between them. No current leaf is
+ *  mutated. */
+export declare function prependOlderLeaves(fresh: readonly TranscriptLeaf[], current: readonly TranscriptLeaf[]): TranscriptLeaf[];
+/** Merge the channel's live window into the folded history: tool records
+ *  pair by call id (live status/previews win while the disk has not
+ *  recorded the result; a call the history never saw appends as live),
+ *  and text/thinking tail lines the loaded history already paints are
+ *  suppressed — a settled block's lines are identical on both sides — so
+ *  history and live neither double a row nor drop a tail. */
+export declare function mergeLiveWindow(leaves: readonly TranscriptLeaf[], subagent: SubagentState, hasHistory: boolean): (TranscriptLeaf | LiveLeaf)[];
+export type TranscriptLoader = (agentId: string, window?: SubagentTranscriptWindow) => Promise<SubagentTranscriptView | null>;
+/**
+ * The paged history of one child: loads the newest page while `active`,
+ * reloads once when `reloadKey` changes (settlement makes the disk copy
+ * final), and prepends older windows on demand.
+ *
+ * The loader and the message feed ride refs: the channel UI proxy mints a
+ * fresh loader per read, and a reload must key on what changed (the child,
+ * activation, settlement), not on a churning identity. An older window is
+ * dropped when the state it was requested for is gone (the view switched
+ * to another agent, or a reload moved the newest page under it).
+ */
+export declare function useSubagentTranscript(loadTranscript: TranscriptLoader | undefined, agentId: string, active: boolean, reloadKey: unknown, messages: readonly AgentMessageView[]): {
+    readonly transcript: TranscriptState;
+    loadOlder(): void;
+};
+export {};
+//# sourceMappingURL=subagentTranscript.d.ts.map

package/lib/types/components/messages/subagentTranscript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagentTranscript.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/subagentTranscript.ts"],"names":[],"mappings":"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"}