@xingular/harness 2.0.0 → 2.0.1-unstable

package/dist/sdk/terminal/tui/thinkingLevels.js

@@ -0,0 +1,31 @@
+// The effort levels a model offers, by Pi's rule (`getSupportedThinkingLevels` and
+// `clampThinkingLevel` in pi-ai): a model that does not reason offers only `off`; `xhigh` and `max`
+// need the model to map them; a map entry of `null` removes a level. The client terminal has no Pi
+// session to ask, so it applies the same rule to the model it resolved.
+import { EFFORTS } from "../../core/effort.js";
+export function supportedLevels(model) {
+    if (!model?.reasoning)
+        return ['off'];
+    return EFFORTS.filter((level) => {
+        const mapped = model.thinkingLevelMap?.[level];
+        if (mapped === null)
+            return false;
+        return level === 'xhigh' || level === 'max' ? mapped !== undefined : true;
+    });
+}
+/** The level a model runs at when asked for `level`: itself, else the nearest above, else the nearest below. */
+export function clampLevel(model, level) {
+    const available = supportedLevels(model);
+    if (available.includes(level))
+        return level;
+    const requested = EFFORTS.indexOf(level);
+    if (requested === -1)
+        return available[0] ?? 'off';
+    for (let index = requested; index < EFFORTS.length; index++)
+        if (available.includes(EFFORTS[index]))
+            return EFFORTS[index];
+    for (let index = requested - 1; index >= 0; index--)
+        if (available.includes(EFFORTS[index]))
+            return EFFORTS[index];
+    return available[0] ?? 'off';
+}

package/dist/sdk/terminal/tui/treeModel.d.ts

@@ -0,0 +1,79 @@
+import type { SessionTreeNode } from '@earendil-works/pi-coding-agent';
+export type TreeFilterMode = 'default' | 'no-tools' | 'user-only' | 'labeled-only' | 'all';
+export declare const TREE_FILTER_MODES: readonly TreeFilterMode[];
+interface Gutter {
+    position: number;
+    show: boolean;
+}
+export interface FlatNode {
+    node: SessionTreeNode;
+    indent: number;
+    showConnector: boolean;
+    isLast: boolean;
+    gutters: Gutter[];
+    isVirtualRootChild: boolean;
+}
+/** A tool call in one short bracketed phrase, such as `[read: ~/project/a.ts:10-40]`. */
+export declare function formatToolCall(name: string, args: Record<string, unknown>): string;
+/** How one entry reads in a row: a lead word, its text, and which color family it belongs to. */
+export interface EntryText {
+    lead: string;
+    leadTone: 'accent' | 'success' | 'muted' | 'dim' | 'warning' | 'error' | 'borderAccent' | 'customMessageLabel';
+    text: string;
+    textTone?: 'muted' | 'dim' | 'error';
+}
+export declare class TreeModel {
+    private readonly currentLeafId;
+    private flat;
+    private filtered;
+    private selectedIndexValue;
+    private lastSelectedId;
+    private multipleRoots;
+    private activePath;
+    private visibleParent;
+    private visibleChildren;
+    private folded;
+    private toolCalls;
+    private query;
+    private mode;
+    showLabelTimestamps: boolean;
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, initialSelectedId?: string | null, initialFilterMode?: TreeFilterMode);
+    get rows(): readonly FlatNode[];
+    get selectedIndex(): number;
+    get selectedNode(): SessionTreeNode | undefined;
+    get filterMode(): TreeFilterMode;
+    get searchQuery(): string;
+    get roots(): boolean;
+    isFolded(id: string): boolean;
+    isOnActivePath(id: string): boolean;
+    private entryMap;
+    /** The row for an entry, or the nearest visible ancestor when a filter hides it. */
+    private nearestVisibleIndex;
+    private buildActivePath;
+    private flatten;
+    private isSettingsEntry;
+    private applyFilter;
+    /** Hiding entries re-attaches their descendants to the nearest visible ancestor, so the connectors are drawn again. */
+    private recalculateVisualStructure;
+    private searchableText;
+    setSearch(query: string): void;
+    setFilter(mode: TreeFilterMode): void;
+    /** Turns a filter on, or back to the default when it is already the one showing. */
+    toggleFilter(mode: TreeFilterMode): void;
+    cycleFilter(direction: 1 | -1): void;
+    move(delta: number, wrap?: boolean): void;
+    /** Folds a foldable branch, or jumps to the start of the branch segment above. */
+    foldOrUp(): void;
+    /** Unfolds a folded branch, or jumps to the next branch point below. */
+    unfoldOrDown(): void;
+    private jump;
+    /** A node can be folded when it has visible children and is a root or the start of a branch segment. */
+    isFoldable(id: string): boolean;
+    private branchSegmentStart;
+    setLabel(entryId: string, label: string | undefined): void;
+    /** The text `Ctrl+X` copies for the selected row, or nothing when it has none. */
+    copyText(node?: SessionTreeNode | undefined): string | undefined;
+    /** How an entry reads in its row. */
+    describe(node: SessionTreeNode): EntryText;
+}
+export {};

package/dist/sdk/terminal/tui/treeModel.js

@@ -0,0 +1,483 @@
+export const TREE_FILTER_MODES = ['default', 'no-tools', 'user-only', 'labeled-only', 'all'];
+const messageOf = (entry) => entry.type === 'message' ? entry.message : undefined;
+function fullContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    let result = '';
+    for (const block of content) {
+        if (typeof block === 'object' && block !== null && block.type === 'text')
+            result += String(block.text ?? '');
+    }
+    return result;
+}
+const content200 = (content) => fullContent(content).slice(0, 200);
+function hasText(content) {
+    if (typeof content === 'string')
+        return content.trim().length > 0;
+    if (!Array.isArray(content))
+        return false;
+    return content.some(block => typeof block === 'object' && block !== null && block.type === 'text' && String(block.text ?? '').trim().length > 0);
+}
+const shorten = (path) => {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    return home && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+};
+/** A tool call in one short bracketed phrase, such as `[read: ~/project/a.ts:10-40]`. */
+export function formatToolCall(name, args) {
+    const path = () => shorten(String(args.path || args.file_path || ''));
+    switch (name) {
+        case 'read': {
+            const { offset, limit } = args;
+            let display = path();
+            if (offset !== undefined || limit !== undefined) {
+                const start = offset ?? 1;
+                const end = limit !== undefined ? start + limit - 1 : '';
+                display += `:${start}${end ? `-${end}` : ''}`;
+            }
+            return `[read: ${display}]`;
+        }
+        case 'write': return `[write: ${path()}]`;
+        case 'edit': return `[edit: ${path()}]`;
+        case 'bash': {
+            const raw = String(args.command || '');
+            return `[bash: ${raw.replace(/[\n\t]/g, ' ').trim().slice(0, 50)}${raw.length > 50 ? '...' : ''}]`;
+        }
+        case 'grep': return `[grep: /${String(args.pattern || '')}/ in ${shorten(String(args.path || '.'))}]`;
+        case 'find': return `[find: ${String(args.pattern || '')} in ${shorten(String(args.path || '.'))}]`;
+        case 'ls': return `[ls: ${shorten(String(args.path || '.'))}]`;
+        default: {
+            const json = JSON.stringify(args);
+            return `[${name}: ${json.slice(0, 40)}${json.length > 40 ? '...' : ''}]`;
+        }
+    }
+}
+export class TreeModel {
+    currentLeafId;
+    flat;
+    filtered = [];
+    selectedIndexValue = 0;
+    lastSelectedId = null;
+    multipleRoots;
+    activePath = new Set();
+    visibleParent = new Map();
+    visibleChildren = new Map();
+    folded = new Set();
+    toolCalls = new Map();
+    query = '';
+    mode;
+    showLabelTimestamps = false;
+    constructor(tree, currentLeafId, initialSelectedId, initialFilterMode = 'default') {
+        this.currentLeafId = currentLeafId;
+        this.mode = initialFilterMode;
+        this.multipleRoots = tree.length > 1;
+        this.flat = this.flatten(tree);
+        this.buildActivePath();
+        this.applyFilter();
+        this.selectedIndexValue = this.nearestVisibleIndex(initialSelectedId ?? currentLeafId);
+        this.lastSelectedId = this.filtered[this.selectedIndexValue]?.node.entry.id ?? null;
+    }
+    get rows() { return this.filtered; }
+    get selectedIndex() { return this.selectedIndexValue; }
+    get selectedNode() { return this.filtered[this.selectedIndexValue]?.node; }
+    get filterMode() { return this.mode; }
+    get searchQuery() { return this.query; }
+    get roots() { return this.multipleRoots; }
+    isFolded(id) { return this.folded.has(id); }
+    isOnActivePath(id) { return this.activePath.has(id); }
+    entryMap() { return new Map(this.flat.map(item => [item.node.entry.id, item])); }
+    /** The row for an entry, or the nearest visible ancestor when a filter hides it. */
+    nearestVisibleIndex(entryId) {
+        if (!this.filtered.length)
+            return 0;
+        const entries = this.entryMap();
+        const visible = new Map(this.filtered.map((item, index) => [item.node.entry.id, index]));
+        let current = entryId ?? null;
+        while (current !== null) {
+            const index = visible.get(current);
+            if (index !== undefined)
+                return index;
+            const item = entries.get(current);
+            if (!item)
+                break;
+            current = item.node.entry.parentId ?? null;
+        }
+        return this.filtered.length - 1;
+    }
+    buildActivePath() {
+        this.activePath.clear();
+        const entries = this.entryMap();
+        let current = this.currentLeafId;
+        while (current) {
+            this.activePath.add(current);
+            const item = entries.get(current);
+            if (!item)
+                break;
+            current = item.node.entry.parentId ?? null;
+        }
+    }
+    flatten(roots) {
+        const result = [];
+        this.toolCalls.clear();
+        const containsActive = new Map();
+        const leafId = this.currentLeafId;
+        const all = [];
+        const pre = [...roots];
+        while (pre.length) {
+            const node = pre.pop();
+            all.push(node);
+            for (let i = node.children.length - 1; i >= 0; i--)
+                pre.push(node.children[i]);
+        }
+        for (let i = all.length - 1; i >= 0; i--) {
+            const node = all[i];
+            let has = leafId !== null && node.entry.id === leafId;
+            for (const child of node.children)
+                if (containsActive.get(child))
+                    has = true;
+            containsActive.set(node, has);
+        }
+        const multipleRoots = roots.length > 1;
+        const ordered = [...roots].sort((a, b) => Number(containsActive.get(b)) - Number(containsActive.get(a)));
+        const stack = [];
+        for (let i = ordered.length - 1; i >= 0; i--)
+            stack.push([ordered[i], multipleRoots ? 1 : 0, multipleRoots, multipleRoots, i === ordered.length - 1, [], multipleRoots]);
+        while (stack.length) {
+            const [node, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild] = stack.pop();
+            const message = messageOf(node.entry);
+            if (message?.role === 'assistant' && Array.isArray(message.content)) {
+                for (const block of message.content) {
+                    const call = block;
+                    if (call && call.type === 'toolCall' && call.id)
+                        this.toolCalls.set(call.id, { name: call.name ?? 'tool', arguments: call.arguments ?? {} });
+                }
+            }
+            result.push({ node, indent, showConnector, isLast, gutters, isVirtualRootChild });
+            const children = node.children;
+            const multipleChildren = children.length > 1;
+            const ordered = [...children.filter(child => containsActive.get(child)), ...children.filter(child => !containsActive.get(child))];
+            const childIndent = multipleChildren ? indent + 1 : justBranched && indent > 0 ? indent + 1 : indent;
+            const displayed = showConnector && !isVirtualRootChild;
+            const position = Math.max(0, (this.multipleRoots ? Math.max(0, indent - 1) : indent) - 1);
+            const childGutters = displayed ? [...gutters, { position, show: !isLast }] : gutters;
+            for (let i = ordered.length - 1; i >= 0; i--)
+                stack.push([ordered[i], childIndent, multipleChildren, multipleChildren, i === ordered.length - 1, childGutters, false]);
+        }
+        return result;
+    }
+    isSettingsEntry(entry) {
+        return entry.type === 'label' || entry.type === 'context_edit' || entry.type === 'custom' || entry.type === 'model_change' || entry.type === 'thinking_level_change' || entry.type === 'session_info';
+    }
+    applyFilter() {
+        if (this.filtered.length > 0)
+            this.lastSelectedId = this.filtered[this.selectedIndexValue]?.node.entry.id ?? this.lastSelectedId;
+        const tokens = this.query.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [];
+        this.filtered = this.flat.filter(item => {
+            const entry = item.node.entry;
+            if (entry.type === 'usage')
+                return false;
+            const message = messageOf(entry);
+            // An assistant turn that only called tools reads as noise, unless it failed or is where the session stands.
+            if (message?.role === 'assistant' && entry.id !== this.currentLeafId) {
+                const failed = message.stopReason && message.stopReason !== 'stop' && message.stopReason !== 'toolUse';
+                if (!hasText(message.content) && !failed)
+                    return false;
+            }
+            const settings = this.isSettingsEntry(entry);
+            let passes;
+            switch (this.mode) {
+                case 'user-only':
+                    passes = message?.role === 'user';
+                    break;
+                case 'no-tools':
+                    passes = !settings && message?.role !== 'toolResult';
+                    break;
+                case 'labeled-only':
+                    passes = item.node.label !== undefined;
+                    break;
+                case 'all':
+                    passes = true;
+                    break;
+                default: passes = !settings;
+            }
+            if (!passes)
+                return false;
+            if (tokens.length) {
+                const words = this.searchableText(item.node).toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [];
+                return tokens.every(token => words.some(word => token.length === 1 ? word === token : word.includes(token)));
+            }
+            return true;
+        });
+        if (this.folded.size) {
+            const skip = new Set();
+            for (const item of this.flat) {
+                const { id, parentId } = item.node.entry;
+                if (parentId != null && (this.folded.has(parentId) || skip.has(parentId)))
+                    skip.add(id);
+            }
+            this.filtered = this.filtered.filter(item => !skip.has(item.node.entry.id));
+        }
+        this.recalculateVisualStructure();
+        if (this.lastSelectedId)
+            this.selectedIndexValue = this.nearestVisibleIndex(this.lastSelectedId);
+        else if (this.selectedIndexValue >= this.filtered.length)
+            this.selectedIndexValue = Math.max(0, this.filtered.length - 1);
+        if (this.filtered.length > 0)
+            this.lastSelectedId = this.filtered[this.selectedIndexValue]?.node.entry.id ?? this.lastSelectedId;
+    }
+    /** Hiding entries re-attaches their descendants to the nearest visible ancestor, so the connectors are drawn again. */
+    recalculateVisualStructure() {
+        if (!this.filtered.length)
+            return;
+        const visibleIds = new Set(this.filtered.map(item => item.node.entry.id));
+        const entries = this.entryMap();
+        const ancestor = (id) => {
+            let current = entries.get(id)?.node.entry.parentId ?? null;
+            while (current !== null) {
+                if (visibleIds.has(current))
+                    return current;
+                current = entries.get(current)?.node.entry.parentId ?? null;
+            }
+            return null;
+        };
+        const parents = new Map();
+        const children = new Map([[null, []]]);
+        for (const item of this.filtered) {
+            const id = item.node.entry.id;
+            const parent = ancestor(id);
+            parents.set(id, parent);
+            if (!children.has(parent))
+                children.set(parent, []);
+            children.get(parent).push(id);
+        }
+        const rootIds = children.get(null);
+        this.multipleRoots = rootIds.length > 1;
+        const byId = new Map(this.filtered.map(item => [item.node.entry.id, item]));
+        const stack = [];
+        for (let i = rootIds.length - 1; i >= 0; i--)
+            stack.push([rootIds[i], this.multipleRoots ? 1 : 0, this.multipleRoots, this.multipleRoots, i === rootIds.length - 1, [], this.multipleRoots]);
+        while (stack.length) {
+            const [id, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild] = stack.pop();
+            const item = byId.get(id);
+            if (!item)
+                continue;
+            Object.assign(item, { indent, showConnector, isLast, gutters, isVirtualRootChild });
+            const visible = children.get(id) ?? [];
+            const multipleChildren = visible.length > 1;
+            const childIndent = multipleChildren ? indent + 1 : justBranched && indent > 0 ? indent + 1 : indent;
+            const displayed = showConnector && !isVirtualRootChild;
+            const position = Math.max(0, (this.multipleRoots ? Math.max(0, indent - 1) : indent) - 1);
+            const childGutters = displayed ? [...gutters, { position, show: !isLast }] : gutters;
+            for (let i = visible.length - 1; i >= 0; i--)
+                stack.push([visible[i], childIndent, multipleChildren, multipleChildren, i === visible.length - 1, childGutters, false]);
+        }
+        this.visibleParent = parents;
+        this.visibleChildren = children;
+    }
+    searchableText(node) {
+        const entry = node.entry;
+        const parts = [];
+        if (node.label)
+            parts.push(node.label);
+        const message = messageOf(entry);
+        if (message) {
+            parts.push(message.role ?? '');
+            if (message.content)
+                parts.push(content200(message.content));
+            if (message.role === 'bashExecution' && message.command)
+                parts.push(message.command);
+        }
+        else
+            switch (entry.type) {
+                case 'custom_message':
+                    parts.push(entry.customType, typeof entry.content === 'string' ? entry.content : content200(entry.content));
+                    break;
+                case 'compaction':
+                    parts.push('compaction');
+                    break;
+                case 'branch_summary':
+                    parts.push('branch summary', entry.summary);
+                    break;
+                case 'session_info':
+                    parts.push('title');
+                    if (entry.name)
+                        parts.push(entry.name);
+                    break;
+                case 'model_change':
+                    parts.push('model', entry.modelId);
+                    break;
+                case 'thinking_level_change':
+                    parts.push('thinking', entry.thinkingLevel);
+                    break;
+                case 'custom':
+                    parts.push('custom', entry.customType);
+                    break;
+                case 'context_edit':
+                    parts.push('context edit', entry.replacement === null ? 'omit' : 'replace', entry.targetId);
+                    break;
+                case 'label':
+                    parts.push('label', entry.label ?? '');
+                    break;
+            }
+        return parts.join(' ');
+    }
+    // ---- Changes ----------------------------------------------------------------------------
+    setSearch(query) {
+        this.query = query;
+        this.folded.clear();
+        this.applyFilter();
+    }
+    setFilter(mode) {
+        this.mode = mode;
+        this.folded.clear();
+        this.applyFilter();
+    }
+    /** Turns a filter on, or back to the default when it is already the one showing. */
+    toggleFilter(mode) { this.setFilter(this.mode === mode ? 'default' : mode); }
+    cycleFilter(direction) {
+        const at = TREE_FILTER_MODES.indexOf(this.mode);
+        this.setFilter(TREE_FILTER_MODES[(at + direction + TREE_FILTER_MODES.length) % TREE_FILTER_MODES.length]);
+    }
+    move(delta, wrap = false) {
+        const count = this.filtered.length;
+        if (!count)
+            return;
+        this.selectedIndexValue = wrap ? (this.selectedIndexValue + delta + count) % count : Math.max(0, Math.min(count - 1, this.selectedIndexValue + delta));
+        this.lastSelectedId = this.filtered[this.selectedIndexValue]?.node.entry.id ?? this.lastSelectedId;
+    }
+    /** Folds a foldable branch, or jumps to the start of the branch segment above. */
+    foldOrUp() {
+        const id = this.filtered[this.selectedIndexValue]?.node.entry.id;
+        if (id && this.isFoldable(id) && !this.folded.has(id)) {
+            this.folded.add(id);
+            this.applyFilter();
+        }
+        else
+            this.jump(this.branchSegmentStart('up'));
+    }
+    /** Unfolds a folded branch, or jumps to the next branch point below. */
+    unfoldOrDown() {
+        const id = this.filtered[this.selectedIndexValue]?.node.entry.id;
+        if (id && this.folded.has(id)) {
+            this.folded.delete(id);
+            this.applyFilter();
+        }
+        else
+            this.jump(this.branchSegmentStart('down'));
+    }
+    jump(index) {
+        this.selectedIndexValue = index;
+        this.lastSelectedId = this.filtered[index]?.node.entry.id ?? this.lastSelectedId;
+    }
+    /** A node can be folded when it has visible children and is a root or the start of a branch segment. */
+    isFoldable(id) {
+        const children = this.visibleChildren.get(id);
+        if (!children?.length)
+            return false;
+        const parent = this.visibleParent.get(id);
+        if (parent === null || parent === undefined)
+            return true;
+        const siblings = this.visibleChildren.get(parent);
+        return siblings !== undefined && siblings.length > 1;
+    }
+    branchSegmentStart(direction) {
+        const selected = this.filtered[this.selectedIndexValue]?.node.entry.id;
+        if (!selected)
+            return this.selectedIndexValue;
+        const index = new Map(this.filtered.map((item, i) => [item.node.entry.id, i]));
+        let current = selected;
+        if (direction === 'down') {
+            for (;;) {
+                const children = this.visibleChildren.get(current) ?? [];
+                if (!children.length)
+                    return index.get(current);
+                if (children.length > 1)
+                    return index.get(children[0]);
+                current = children[0];
+            }
+        }
+        for (;;) {
+            const parent = this.visibleParent.get(current) ?? null;
+            if (parent === null)
+                return index.get(current);
+            const siblings = this.visibleChildren.get(parent) ?? [];
+            if (siblings.length > 1) {
+                const start = index.get(current);
+                if (start < this.selectedIndexValue)
+                    return start;
+            }
+            current = parent;
+        }
+    }
+    setLabel(entryId, label) {
+        const item = this.flat.find(candidate => candidate.node.entry.id === entryId);
+        if (!item)
+            return;
+        item.node.label = label;
+        item.node.labelTimestamp = label ? new Date().toISOString() : undefined;
+        this.applyFilter();
+    }
+    // ---- Reading ----------------------------------------------------------------------------
+    /** The text `Ctrl+X` copies for the selected row, or nothing when it has none. */
+    copyText(node = this.selectedNode) {
+        if (!node)
+            return undefined;
+        const entry = node.entry;
+        let text;
+        const message = messageOf(entry);
+        if (message) {
+            if (message.role === 'bashExecution')
+                text = message.command;
+            else if ('content' in message) {
+                text = fullContent(message.content);
+                if (!text && message.role === 'assistant')
+                    text = message.errorMessage;
+            }
+        }
+        else if (entry.type === 'custom_message')
+            text = fullContent(entry.content);
+        else if (entry.type === 'compaction' || entry.type === 'branch_summary')
+            text = entry.summary;
+        return text?.trim() ? text : undefined;
+    }
+    /** How an entry reads in its row. */
+    describe(node) {
+        const entry = node.entry;
+        const flat = (value) => value.replace(/[\n\t]/g, ' ').trim();
+        const message = messageOf(entry);
+        if (message) {
+            if (message.role === 'user')
+                return { lead: 'user: ', leadTone: 'accent', text: flat(content200(message.content)) };
+            if (message.role === 'assistant') {
+                const text = flat(content200(message.content));
+                if (text)
+                    return { lead: 'assistant: ', leadTone: 'success', text };
+                if (message.stopReason === 'aborted')
+                    return { lead: 'assistant: ', leadTone: 'success', text: '(aborted)', textTone: 'muted' };
+                if (message.errorMessage)
+                    return { lead: 'assistant: ', leadTone: 'success', text: flat(message.errorMessage).slice(0, 80), textTone: 'error' };
+                return { lead: 'assistant: ', leadTone: 'success', text: '(no content)', textTone: 'muted' };
+            }
+            if (message.role === 'toolResult') {
+                const call = message.toolCallId ? this.toolCalls.get(message.toolCallId) : undefined;
+                return { lead: '', leadTone: 'muted', text: call ? formatToolCall(call.name, call.arguments) : `[${message.toolName ?? 'tool'}]`, textTone: 'muted' };
+            }
+            if (message.role === 'bashExecution')
+                return { lead: '', leadTone: 'dim', text: `[bash]: ${flat(message.command ?? '')}`, textTone: 'dim' };
+            return { lead: '', leadTone: 'dim', text: `[${message.role}]`, textTone: 'dim' };
+        }
+        switch (entry.type) {
+            case 'custom_message': return { lead: `[${entry.customType}]: `, leadTone: 'customMessageLabel', text: flat(typeof entry.content === 'string' ? entry.content : fullContent(entry.content)) };
+            case 'compaction': return { lead: '', leadTone: 'borderAccent', text: `[compaction: ${Math.round(entry.tokensBefore / 1000)}k tokens]` };
+            case 'branch_summary': return { lead: '[branch summary]: ', leadTone: 'warning', text: flat(entry.summary) };
+            case 'model_change': return { lead: '', leadTone: 'dim', text: `[model: ${entry.modelId}]`, textTone: 'dim' };
+            case 'thinking_level_change': return { lead: '', leadTone: 'dim', text: `[thinking: ${entry.thinkingLevel}]`, textTone: 'dim' };
+            case 'custom': return { lead: '', leadTone: 'dim', text: `[custom: ${entry.customType}]`, textTone: 'dim' };
+            case 'context_edit': return { lead: '', leadTone: 'dim', text: `[context ${entry.replacement === null ? 'omit' : 'replace'}: ${entry.targetId}]`, textTone: 'dim' };
+            case 'label': return { lead: '', leadTone: 'dim', text: `[label: ${entry.label ?? '(cleared)'}]`, textTone: 'dim' };
+            case 'session_info': return { lead: '', leadTone: 'dim', text: `[title: ${entry.name || 'empty'}]`, textTone: 'dim' };
+            default: return { lead: '', leadTone: 'dim', text: '' };
+        }
+    }
+}

package/dist/sdk/terminal/tui/treePicker.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The `/tree` page: the session's branches as a tree, searched in the standard place, filtered by
+ * entry kind, folded by branch, labelled and copied. Enter goes to the selected entry; what
+ * follows (summarising the branch left behind) is the command's.
+ */
+import type { SessionTreeNode, Theme } from '@earendil-works/pi-coding-agent';
+import { type Component, type Focusable, type TUI } from '@earendil-works/pi-tui';
+import { TREE_FILTER_MODES, TreeModel, type TreeFilterMode } from "./treeModel.js";
+export interface TreePickerOptions {
+    theme: () => Theme;
+    tui: TUI;
+    /** Whether a key press is one of the named application actions, such as `app.tree.foldOrUp`. */
+    matches(data: string, action: string): boolean;
+    tree: SessionTreeNode[];
+    currentLeafId: string | null;
+    initialFilterMode?: TreeFilterMode;
+    select(entryId: string): void;
+    cancel(): void;
+    copy(text: string): void;
+    /** Asks for a label; `undefined` means the person backed out, an empty string removes the label. */
+    editLabel(entryId: string, current: string | undefined): Promise<string | undefined>;
+    /** Records a label change in the session. */
+    labelChanged(entryId: string, label: string | undefined): void;
+    changed(): void;
+}
+export declare class TreePicker implements Component, Focusable {
+    private readonly options;
+    private readonly model;
+    private readonly search;
+    private focusedValue;
+    private editing;
+    private closed;
+    constructor(options: TreePickerOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    get state(): TreeModel;
+    invalidate(): void;
+    dispose(): void;
+    private cancel;
+    private editLabel;
+    handleInput(data: string): void;
+    private searchRows;
+    /** Rows the list can show: the page (or dialog), less the frame, the search field and filter strip. */
+    private listRows;
+    private prefix;
+    private row;
+    render(width: number): string[];
+}
+export { TREE_FILTER_MODES, type TreeFilterMode };