@pasko70/pibo 1.1.0 → 1.3.0

package/dist/apps/cli-ui/InkTerminalLine.js

@@ -0,0 +1,53 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { redactTerminalSecret } from "../../session-ui/index.js";
+import { colorForTone } from "./inkColors.js";
+import { formatFunctionCallTokens } from "./inkJson.js";
+export function InkTerminalLine({ line, leadingMarker, leadingColor, maxChars = 220 }) {
+    const chunks = buildLineChunks(line, maxChars);
+    return React.createElement(Box, { flexDirection: "row" }, React.createElement(Text, { color: leadingColor, key: "marker" }, markerText(line, leadingMarker)), React.createElement(Text, { key: "content" }, " ", ...chunks.map((chunk, index) => React.createElement(Text, {
+        bold: chunk.weight === "bold" || chunk.weight === "semibold",
+        color: colorForTone(chunk.tone),
+        dimColor: chunk.tone === "dim",
+        italic: chunk.italic,
+        key: `token-${index}`,
+    }, chunk.text))));
+}
+export function linePrefixSymbol(prefix) {
+    switch (prefix) {
+        case "prompt":
+            return "›";
+        case "bullet":
+            return "•";
+        case "detail":
+            return "↳";
+        case "continuation":
+            return " ";
+        case "none":
+        case undefined:
+        default:
+            return " ";
+    }
+}
+function markerText(line, leadingMarker) {
+    const prefix = linePrefixSymbol(line.prefix);
+    if (leadingMarker === undefined)
+        return prefix;
+    if (prefix.trim() && prefix !== leadingMarker)
+        return `${leadingMarker} ${prefix}`;
+    return leadingMarker;
+}
+function buildLineChunks(line, _maxChars) {
+    const chunks = [...line.tokens];
+    if (line.functionCall) {
+        if (line.functionCall.input === undefined)
+            chunks.push({ text: line.functionCall.name, tone: "yellow", weight: "semibold" });
+        else
+            chunks.push(...formatFunctionCallTokens(line.functionCall.name, line.functionCall.input));
+    }
+    if (chunks.length === 0)
+        return [{ text: "∅", tone: "dim" }];
+    return chunks
+        .map((chunk) => ({ ...chunk, text: redactTerminalSecret(chunk.text).replace(/\n/g, " ") }))
+        .filter((chunk) => chunk.text.length > 0);
+}

package/dist/apps/cli-ui/InkTerminalRow.js

@@ -0,0 +1,304 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { buildTerminalCardDescriptor, progressBarText, redactTerminalSecret } from "../../session-ui/index.js";
+import { colorForRowKind, colorForStatus, colorForTone, markerForStatus } from "./inkColors.js";
+import { formatDetailJsonWellLines, formatInkJson } from "./inkJson.js";
+import { renderInkMarkdownTerminalLines } from "./inkMarkdown.js";
+import { InkTerminalLine } from "./InkTerminalLine.js";
+export function InkTerminalRow({ row, maxLineChars = 220, maxMarkdownLines = 80, isExpanded = false, isSelected = false }) {
+    const card = isStructuredCardException(row) ? buildTerminalCardDescriptor(row) : undefined;
+    const detailLines = isExpanded ? rowDetailLines(row, maxLineChars) : [];
+    const selectedHint = isSelected && isExpandableTerminalRow(row) && !isExpanded
+        ? [React.createElement(Text, { color: "cyan", key: `${row.id}:selected-detail-hint` }, "  ↳ details available · press d or enter")]
+        : [];
+    if (card)
+        return React.createElement(Box, { flexDirection: "column" }, React.createElement(InkTerminalCard, { card, maxLineChars }), ...selectedHint, ...detailLines);
+    const lines = rowLines(row, maxMarkdownLines);
+    const statusColor = colorForStatus(row.status);
+    return React.createElement(Box, { flexDirection: "column" }, ...lines.map((line, index) => React.createElement(InkTerminalLine, {
+        key: `${row.id}-${index}`,
+        leadingColor: index === 0 ? rowMarkerColor(row) ?? statusColor : undefined,
+        leadingMarker: index === 0 ? rowMarker(row) : " ",
+        line,
+        maxChars: maxLineChars,
+    })), ...selectedHint, ...detailLines);
+}
+function isStructuredCardException(row) {
+    return row.kind === "tool.status"
+        || row.kind === "tool.thinking"
+        || row.kind === "tool.login"
+        || row.kind === "tool.model";
+}
+export function isExpandableTerminalRow(row) {
+    return row.expandable === true
+        || row.input !== undefined
+        || row.output !== undefined
+        || Boolean(row.error)
+        || Boolean(row.linkedPiboSessionId)
+        || Boolean(row.previewOmission)
+        || Boolean(row.detailItems?.length);
+}
+export function InkTerminalCard({ card, maxLineChars: _maxLineChars = 220 }) {
+    const marker = markerForStatus(card.status);
+    const color = colorForCardTone(card.tone) ?? colorForStatus(card.status);
+    const statusLabel = card.status === "neutral" ? card.kind : `${card.kind} · ${card.status}`;
+    const statusSummary = card.kind === "status" ? statusCardSummary(card) : undefined;
+    const lines = [
+        React.createElement(Text, { color, key: "header", bold: true }, cardLine(`${marker} ▣ ${card.title} — ${statusLabel}${statusSummary ? ` · ${statusSummary}` : ""}`)),
+    ];
+    if (card.kind === "status") {
+        lines.push(...statusCardCompactRows(card));
+    }
+    else {
+        for (const [index, row] of card.rows.entries()) {
+            const text = row.label ? `  ↳ ${row.label}: ${row.value}` : `  ↳ ${row.value}`;
+            lines.push(React.createElement(Text, { color: colorForCardTone(row.tone) ?? "white", key: `row-${index}` }, cardLine(text)));
+        }
+    }
+    for (const progress of card.statusView?.progress ?? []) {
+        const bar = inkProgressBarText(progress, 18);
+        const detail = progress.state === "available" ? ` — ${progress.text}` : "";
+        lines.push(React.createElement(Text, { color: progress.tone === "neutral" ? "gray" : colorForTone(progress.tone), key: `progress-${progress.id}` }, cardLine(`  ↳ ${progress.label}: ${bar}${detail}`)));
+    }
+    for (const [index, warning] of (card.statusView?.warnings ?? []).entries()) {
+        lines.push(React.createElement(Text, { color: "yellow", key: `warning-${index}` }, cardLine(`  ⚠ ${warning}`)));
+    }
+    for (const [index, error] of (card.statusView?.errors ?? []).entries()) {
+        lines.push(React.createElement(Text, { color: "red", key: `error-${index}` }, cardLine(`  ✕ ${error}`)));
+    }
+    if (card.actions?.length) {
+        const actions = card.actions.map((action) => `${action.disabled ? "-" : "•"} ${action.label}`).join("  ");
+        lines.push(React.createElement(Text, { color: "gray", key: "actions" }, cardLine(`  Actions: ${actions}`)));
+    }
+    if (lines.length === 1)
+        lines.push(React.createElement(Text, { color: "gray", key: "empty" }, "  ↳ No details"));
+    return React.createElement(Box, { flexDirection: "column" }, ...lines);
+}
+export function rowMarker(row) {
+    if (row.kind === "message.user")
+        return "›";
+    if (row.kind === "message.assistant")
+        return row.status === "running" ? "…" : " ";
+    if (row.kind === "error")
+        return "✕";
+    return markerForStatus(row.status);
+}
+function rowMarkerColor(row) {
+    return row.status === "error" ? colorForStatus("error") : colorForRowKind(row.kind);
+}
+function colorForCardTone(tone) {
+    if (tone === "neutral")
+        return "gray";
+    return colorForTone(tone);
+}
+function statusCardSummary(card) {
+    const fields = statusFieldMap(card);
+    const runtime = fields.get("runtime") ?? card.status;
+    const session = shortStatusValue(fields.get("session"));
+    const model = shortStatusValue(fields.get("model"));
+    return [runtime, session ? `session ${session}` : undefined, model ? `model ${model}` : undefined].filter(Boolean).join(" · ");
+}
+function statusCardCompactRows(card) {
+    const fields = statusFieldMap(card);
+    const rows = [];
+    const identity = [
+        fields.get("session") ? `session ${shortStatusValue(fields.get("session"))}` : undefined,
+        fields.get("profile") ? `profile ${fields.get("profile")}` : undefined,
+        fields.get("model") ? `model ${fields.get("model")}` : undefined,
+    ].filter(Boolean).join(" · ");
+    if (identity)
+        rows.push(statusCardRow("identity", "Identity", identity));
+    const runtime = [
+        fields.get("runtime"),
+        fieldIfMeaningful("queue", fields.get("queue")),
+        fieldIfMeaningful("processing", fields.get("processing")),
+        fieldIfMeaningful("streaming", fields.get("streaming")),
+        fieldIfMeaningful("disposed", fields.get("disposed")),
+        fields.get("session-status") ? `session ${fields.get("session-status")}` : undefined,
+    ].filter(Boolean).join(" · ");
+    if (runtime)
+        rows.push(statusCardRow("runtime", "Runtime", runtime, statusRuntimeTone(fields)));
+    const location = fields.get("cwd");
+    if (location)
+        rows.push(statusCardRow("location", "CWD", location));
+    const settings = [
+        fields.get("thinking") ? `thinking ${fields.get("thinking")}` : undefined,
+        fieldIfEnabled("fast", fields.get("fast-mode")),
+    ].filter(Boolean).join(" · ");
+    if (settings)
+        rows.push(statusCardRow("settings", "Settings", settings, "yellow"));
+    const provider = [
+        fields.get("provider-plan") ? `plan ${fields.get("provider-plan")}` : undefined,
+        fields.get("provider-credits") ? `credits ${fields.get("provider-credits")}` : undefined,
+    ].filter(Boolean).join(" · ");
+    if (provider)
+        rows.push(statusCardRow("provider", "Provider", provider));
+    const tools = [
+        fields.get("enabled-tools") ? `enabled ${foldedToolCount(fields.get("enabled-tools"))}` : undefined,
+        fields.get("active-tools") ? `active ${activeToolSummary(fields.get("active-tools"))}` : undefined,
+    ].filter(Boolean).join(" · ");
+    if (tools)
+        rows.push(statusCardRow("tools", "Tools", `${tools} · names in details`, "cyan"));
+    const message = fields.get("message");
+    if (message)
+        rows.push(statusCardRow("message", "Message", message, "neutral"));
+    return rows;
+}
+function statusCardRow(id, label, value, tone = "neutral") {
+    return React.createElement(Text, { color: colorForCardTone(tone) ?? "white", key: `status-${id}` }, cardLine(`  ↳ ${label}: ${value}`));
+}
+function statusFieldMap(card) {
+    return new Map((card.statusView?.fields ?? []).map((field) => [field.id, field.value]));
+}
+function statusRuntimeTone(fields) {
+    if (fields.get("disposed") === "yes" || fields.get("runtime") === "disconnected")
+        return "red";
+    if (fields.get("processing") === "yes" || fields.get("streaming") === "yes")
+        return "cyan";
+    return "green";
+}
+function fieldIfMeaningful(label, value) {
+    if (!value || value === "no" || value === "0")
+        return undefined;
+    return `${label} ${value}`;
+}
+function fieldIfEnabled(label, value) {
+    if (!value || value === "off" || value === "no")
+        return undefined;
+    return `${label} ${value}`;
+}
+function foldedToolCount(value) {
+    if (!value)
+        return undefined;
+    const count = value.match(/^\d+/)?.[0] ?? value;
+    return `${count} folded`;
+}
+function activeToolSummary(value) {
+    if (!value)
+        return undefined;
+    const names = value.match(/\(([^)]+)\)/)?.[1];
+    return names ?? foldedToolCount(value);
+}
+function shortStatusValue(value) {
+    if (!value)
+        return undefined;
+    return value.split("|")[0]?.trim() || value;
+}
+function cardLine(value) {
+    return value.replace(/\s+/g, " ");
+}
+function inkProgressBarText(progress, width) {
+    const boundedWidth = Math.max(4, Math.min(80, Math.floor(width)));
+    const ascii = shouldUseAsciiProgress();
+    if (progress.state !== "available" || progress.percent === undefined) {
+        const empty = ascii ? "-".repeat(boundedWidth) : "░".repeat(boundedWidth);
+        return `unavailable · ${empty}`;
+    }
+    const text = progressBarText(progress, boundedWidth);
+    if (!ascii)
+        return text;
+    const filled = Math.round((Math.max(0, Math.min(100, progress.percent)) / 100) * boundedWidth);
+    return `${"#".repeat(filled)}${"-".repeat(boundedWidth - filled)} ${progress.percent.toFixed(1)}%`;
+}
+function shouldUseAsciiProgress() {
+    return Boolean(process.env.NO_COLOR) || process.env.TERM === "dumb" || process.env.PIBO_ASCII_PROGRESS === "1";
+}
+function rowDetailLines(row, maxLineChars) {
+    const details = detailsForExpandedRow(row);
+    if (!details.length)
+        return [];
+    const lines = [
+        React.createElement(Text, { color: "yellow", key: `${row.id}:details-header`, bold: true }, "  └ Details"),
+    ];
+    for (const [index, detail] of details.entries()) {
+        for (const [lineIndex, text] of detailTextLines(detail, maxLineChars).entries()) {
+            lines.push(React.createElement(Text, {
+                color: detail.status === "error" ? "red" : "gray",
+                key: `${row.id}:detail:${detail.id}:${index}:${lineIndex}`,
+            }, lineIndex === 0 ? `    ${text}` : `      ${text}`));
+        }
+    }
+    return lines;
+}
+function detailsForExpandedRow(row) {
+    const details = [...(row.detailItems ?? [])];
+    if (details.length === 0 && (row.input !== undefined || row.output !== undefined || row.error || row.linkedPiboSessionId || row.previewOmission)) {
+        details.push({
+            id: `${row.id}:row-details`,
+            label: "Row details",
+            status: row.status,
+            input: row.input,
+            output: row.output,
+            error: row.error,
+            linkedPiboSessionId: row.linkedPiboSessionId,
+            previewOmission: row.previewOmission,
+        });
+    }
+    if (row.linkedPiboSessionId && !details.some((item) => item.linkedPiboSessionId === row.linkedPiboSessionId)) {
+        details.push({ id: `${row.id}:linked-session`, label: "Linked session", status: "done", linkedPiboSessionId: row.linkedPiboSessionId });
+    }
+    return details;
+}
+function detailTextLines(detail, maxLineChars) {
+    const label = detail.status === "error" && !/error/i.test(detail.label) ? `${detail.label} error` : detail.label;
+    const lines = [`${label}:`];
+    if (detail.previewOmission) {
+        const source = sectionLabel(detail.previewOmission.source);
+        lines.push(`${source}: ${detail.previewOmission.totalLineCount} lines total · ${detail.previewOmission.omittedLineCount} hidden while collapsed`);
+    }
+    if (detail.linkedPiboSessionId)
+        lines.push(`Linked session: ${redactTerminalSecret(detail.linkedPiboSessionId)}`);
+    if (detail.input !== undefined)
+        lines.push("Input:", ...detailValueLines(detail.input, maxLineChars));
+    if (detail.output !== undefined)
+        lines.push("Output:", ...detailValueLines(detail.output, maxLineChars));
+    if (detail.error)
+        lines.push("Error:", ...redactedTextLines(detail.error));
+    if (lines.length === 1)
+        lines.push(detail.status);
+    return lines;
+}
+function sectionLabel(source) {
+    if (source === "input")
+        return "Input";
+    if (source === "error")
+        return "Error";
+    if (source === "details")
+        return "Details";
+    return "Output";
+}
+function detailValueLines(value, maxLineChars) {
+    const jsonWell = formatDetailJsonWellLines(value, { maxChars: Math.min(1600, Math.max(420, maxLineChars * 8)), maxDepth: 2, maxArrayItems: 12, maxObjectKeys: 20 });
+    if (jsonWell)
+        return jsonWell;
+    const text = typeof value === "string"
+        ? value
+        : formatInkJson(value, { maxChars: Math.min(1600, Math.max(420, maxLineChars * 8)), maxDepth: 4, maxArrayItems: 12, maxObjectKeys: 20 });
+    return redactedTextLines(text);
+}
+function redactedTextLines(value) {
+    const redacted = redactTerminalSecret(value).trimEnd();
+    const lines = redacted.split(/\r?\n/);
+    return lines.length > 0 && lines.some((line) => line.length > 0) ? lines : ["∅"];
+}
+function rowLines(row, maxMarkdownLines) {
+    if (row.lines.length > 0)
+        return row.lines;
+    if (row.markdown || typeof row.output === "string") {
+        const markdown = row.markdown ?? String(row.output ?? "");
+        return renderInkMarkdownTerminalLines(markdown, { maxLines: maxMarkdownLines, reasoning: row.kind === "reasoning" });
+    }
+    if (row.error)
+        return [{ prefix: "none", tokens: [{ text: row.error, tone: "red", weight: "semibold" }] }];
+    if (row.output !== undefined)
+        return jsonLines(row.output);
+    if (row.input !== undefined)
+        return jsonLines(row.input);
+    return [{ prefix: "none", tokens: [{ text: fallbackLabel(row), tone: "dim" }] }];
+}
+function jsonLines(value) {
+    return formatInkJson(value).split("\n").map((text) => ({ prefix: "none", tokens: [{ text, tone: "dim" }] }));
+}
+function fallbackLabel(row) {
+    return `${row.kind} ${row.status}`.trim();
+}

package/dist/apps/cli-ui/InkTerminalView.js

@@ -0,0 +1,25 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { InkTerminalRow } from "./InkTerminalRow.js";
+const DEFAULT_MAX_ROWS = 200;
+export function InkTerminalView({ rows, maxRows = DEFAULT_MAX_ROWS, maxLineChars, showOmittedCount = true, selectedRowId, expandedRowIds = [] }) {
+    const windowedRows = rowWindow(rows, maxRows);
+    const omitted = Math.max(0, rows.length - windowedRows.length);
+    const expanded = new Set(expandedRowIds);
+    return React.createElement(Box, { flexDirection: "column" }, ...(showOmittedCount && omitted > 0
+        ? [React.createElement(Text, { color: "gray", key: "omitted" }, `… ${omitted} earlier rows omitted`)]
+        : []), ...windowedRows.map((row) => React.createElement(InkTerminalRow, {
+        key: row.id,
+        maxLineChars,
+        row,
+        isExpanded: expanded.has(row.id),
+        isSelected: row.id === selectedRowId,
+    })));
+}
+export function rowWindow(rows, maxRows = DEFAULT_MAX_ROWS) {
+    if (!Number.isFinite(maxRows) || maxRows <= 0)
+        return [];
+    if (rows.length <= maxRows)
+        return rows;
+    return rows.slice(rows.length - maxRows);
+}

package/dist/apps/cli-ui/cliSessionsCommand.js

@@ -0,0 +1,232 @@
+import { randomUUID } from "node:crypto";
+import React from "react";
+import { render } from "ink";
+import { createCustomAgentProfileDefinition } from "../../apps/chat/agent-profiles.js";
+import { createDefaultCustomAgentStore } from "../../apps/chat/agent-store.js";
+import { createDefaultFakeCliSessionSource, LocalCliSessionSource } from "../../cli-session/index.js";
+import { PiboSessionRouter } from "../../core/session-router.js";
+import { PiboDataStore } from "../../data/pibo-store.js";
+import { createDefaultPiboPluginRegistry } from "../../plugins/builtin.js";
+import { PiboDataSessionStore } from "../../sessions/pibo-data-store.js";
+import { cliCommandSummaryText, InkSessionApp } from "./InkSessionApp.js";
+export async function runCliSessionsUi(options = {}) {
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    if (options.allowNonTty !== true && (stdin.isTTY !== true || stdout.isTTY !== true)) {
+        stderr.write("pibo tui:sessions requires interactive stdin and stdout TTYs. Re-run from a terminal, SSH session, or use --help for command usage.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const debugPtyMockedSource = process.env.PIBO_DEBUG_PTY_CLI_SESSIONS_MOCKED === "1";
+    const source = options.source ?? (options.useFakeSource
+        ? createDefaultFakeCliSessionSource()
+        : debugPtyMockedSource
+            ? createDebugMockedLocalCliSessionSource({ assistantReply: process.env.PIBO_DEBUG_PTY_ASSISTANT_REPLY ?? "Mocked PTY assistant response" })
+            : createDefaultLocalCliSessionSource());
+    const instance = render(React.createElement(InkSessionApp, {
+        initialSessionId: options.initialSessionId,
+        maxLineChars: options.maxLineChars ?? terminalLineLimitFromColumns(stdout.columns),
+        maxRows: options.maxRows,
+        source,
+    }), {
+        stdin,
+        stdout,
+        stderr,
+    });
+    await instance.waitUntilExit();
+}
+export function createDefaultLocalCliSessionSource() {
+    const context = createLocalCliSessionSourceContext();
+    const router = new PiboSessionRouter({ sessionStore: context.sessionStore, pluginRegistry: context.pluginRegistry });
+    return createLocalCliSessionSourceFromContext({ ...context, router, ownsRouter: true });
+}
+function createDebugMockedLocalCliSessionSource(options) {
+    const context = createLocalCliSessionSourceContext();
+    const debugRooms = debugRoomSummariesFromEnv();
+    const router = new DebugMockCliSessionRouter(options.assistantReply);
+    return createLocalCliSessionSourceFromContext({
+        ...context,
+        router,
+        ownsRouter: true,
+        roomProvider: debugRooms.length > 0 ? { listRooms: () => debugRooms } : undefined,
+        statusMessage: "Debug PTY mocked local router",
+    });
+}
+function debugRoomSummariesFromEnv() {
+    const raw = process.env.PIBO_DEBUG_PTY_CLI_SESSIONS_ROOMS;
+    if (!raw)
+        return [];
+    const rooms = [];
+    for (const entry of raw.split(";").map((value) => value.trim()).filter(Boolean)) {
+        const parts = entry.split("|").map((part) => part?.trim());
+        const [id, title, description] = parts.length >= 4 ? parts.slice(1) : parts;
+        if (id && title)
+            rooms.push({ id, title, description: description || "Debug PTY room fixture", isDefault: title === "Shared Chat" });
+    }
+    return rooms;
+}
+function createLocalCliSessionSourceContext() {
+    const dataStore = new PiboDataStore();
+    const sessionStore = new PiboDataSessionStore(dataStore);
+    const pluginRegistry = createDefaultPiboPluginRegistry();
+    const builtInAgentSummaries = pluginRegistry.getProfileInfos().map((profile) => ({ id: profile.name, name: profile.name, description: profile.description, profileName: profile.name }));
+    const customAgentStore = createDefaultCustomAgentStore();
+    const customAgents = customAgentStore.list();
+    try {
+        for (const agent of customAgents)
+            pluginRegistry.upsertProfile(createCustomAgentProfileDefinition(agent, { missingReferenceMode: "silent" }));
+    }
+    finally {
+        customAgentStore.close();
+    }
+    const agentSummaries = [
+        ...builtInAgentSummaries,
+        ...customAgents.map((agent) => ({ id: agent.profileName, name: agent.profileName, description: agent.description || agent.displayName, profileName: agent.profileName })),
+    ];
+    return { dataStore, sessionStore, pluginRegistry, agentSummaries };
+}
+function createLocalCliSessionSourceFromContext(input) {
+    return new LocalCliSessionSource({
+        sessionStore: input.sessionStore,
+        ownsSessionStore: true,
+        pluginRegistry: input.pluginRegistry,
+        router: input.router,
+        ownsRouter: input.ownsRouter,
+        dataStore: input.dataStore,
+        ownsDataStore: true,
+        agentSummaries: input.agentSummaries,
+        roomProvider: input.roomProvider,
+        statusMessage: input.statusMessage,
+    });
+}
+class DebugMockCliSessionRouter {
+    assistantReply;
+    listeners = new Set();
+    statuses = new Map();
+    constructor(assistantReply) {
+        this.assistantReply = assistantReply;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async emit(event) {
+        if (event.type !== "message") {
+            const result = { type: "execution_result", piboSessionId: event.piboSessionId, eventId: event.id, action: event.action, result: this.executionResult(event) };
+            this.publish(result);
+            return result;
+        }
+        const eventId = event.id ?? randomUUID();
+        this.statuses.set(event.piboSessionId, this.status(event.piboSessionId, { processing: true, queuedMessages: 1 }));
+        this.publish({ type: "message_queued", piboSessionId: event.piboSessionId, eventId, queuedMessages: 1, text: event.text, source: event.source });
+        this.statuses.set(event.piboSessionId, this.status(event.piboSessionId, { processing: true, queuedMessages: 0 }));
+        this.publish({ type: "message_started", piboSessionId: event.piboSessionId, eventId, text: event.text, source: event.source });
+        const assistant = { type: "assistant_message", piboSessionId: event.piboSessionId, eventId, assistantIndex: 0, contentIndex: 0, text: this.assistantReply };
+        this.publish(assistant);
+        const finished = { type: "message_finished", piboSessionId: event.piboSessionId, eventId, source: event.source };
+        this.statuses.set(event.piboSessionId, this.status(event.piboSessionId, { processing: false, queuedMessages: 0 }));
+        this.publish(finished);
+        return assistant;
+    }
+    getSessionRuntimeStatus(piboSessionId) {
+        return this.statuses.get(piboSessionId) ?? this.status(piboSessionId);
+    }
+    async disposeAll() {
+        this.listeners.clear();
+        this.statuses.clear();
+    }
+    publish(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+    executionResult(event) {
+        const params = "params" in event && event.params && typeof event.params === "object" && !Array.isArray(event.params) ? event.params : {};
+        if (event.action === "fast_mode")
+            return { mode: "fast", supported: true, changed: true };
+        if (event.action === "thinking") {
+            const level = typeof params.level === "string" ? params.level : undefined;
+            if (level)
+                return { message: `Thinking level set to ${level}`, level, supported: true, changed: true };
+            return { action: "show_thinking_menu", items: ["off", "minimal", "low", "medium", "high", "xhigh"].map((value) => ({ id: value, label: value })) };
+        }
+        if (event.action === "model") {
+            const model = typeof params.model === "string" ? params.model : undefined;
+            const provider = typeof params.provider === "string" ? params.provider : "openai";
+            if (model)
+                return { message: `Model set to ${provider}/${model}`, provider, model, supported: true, changed: true };
+            return { action: "show_model_menu", providers: [{ id: "openai", label: "OpenAI", description: "Debug PTY provider", models: [{ id: "gpt-pty-large", label: "GPT PTY Large" }, { id: "gpt-pty-mini", label: "GPT PTY Mini" }] }, { id: "offline", label: "Offline Provider", description: "Unavailable in debug PTY", disabled: true, reason: "Debug provider has no credentials", models: [{ id: "offline-model", label: "Offline Model", disabled: true, reason: "Provider unavailable" }] }] };
+        }
+        if (event.action === "login") {
+            return { action: "show_login_menu", providers: [{ id: "openai-codex", name: "OpenAI (ChatGPT Plus/Pro)", authMethods: ["device_code"], configured: false }, { id: "openai", name: "OpenAI API", authMethods: ["api_key"], configured: false }] };
+        }
+        if (event.action === "login.start")
+            return { message: `Open ${params.provider ?? "provider"} login URL https://example.test/device and enter code PTY-1234. Complete sign-in in a browser, then return to the terminal.`, url: "https://example.test/device", userCode: "PTY-1234" };
+        if (event.action === "session.fork_candidates")
+            return { action: "show_fork_candidates", messages: [{ entryId: "entry_pty_1", text: "Fork from PTY prompt one" }, { entryId: "entry_pty_2", text: "Fork from PTY prompt two" }] };
+        if (event.action === "session.fork")
+            return { supported: false, unsupportedReason: "Debug PTY mocked router cannot fork Pi session state; live routed sessions return a visible fork when supported." };
+        if (event.action === "compact")
+            return { queued: true, queuedMessages: 1 };
+        if (event.action === "clear_queue")
+            return { cleared: 0 };
+        if (event.action === "abort")
+            return { aborted: true };
+        if (event.action === "kill")
+            return { killed: [event.piboSessionId], cancelledRuns: [] };
+        if (event.action === "kill_all")
+            return { killed: [event.piboSessionId], cancelledRuns: [] };
+        if (event.action === "session.clone")
+            return { supported: false, unsupportedReason: "Debug PTY mocked router cannot clone Pi session state; live routed sessions return a derived session id when clone succeeds." };
+        return { mocked: true, action: event.action };
+    }
+    status(piboSessionId, overrides = {}) {
+        return {
+            piboSessionId,
+            queuedMessages: 0,
+            processing: false,
+            streaming: false,
+            activeTools: [],
+            enabledTools: [],
+            cwd: process.cwd(),
+            disposed: false,
+            thinkingLevel: "high",
+            fastMode: false,
+            contextUsage: { tokens: 128, contextWindow: 1024, percent: 12.5 },
+            providerUsage: { provider: "openai", planType: "debug", limits: [{ label: "requests", usedPercent: 25 }] },
+            warnings: ["Debug PTY status fixture redacts TOKEN=secret-value"],
+            ...overrides,
+        };
+    }
+}
+export function terminalLineLimitFromColumns(columns) {
+    if (columns === undefined || !Number.isFinite(columns) || columns <= 0)
+        return undefined;
+    return Math.max(20, Math.floor(columns) - 4);
+}
+export function cliSessionsHelpText() {
+    return `pibo tui:sessions - reduced Web Chat-derived session UI for terminals
+
+Usage:
+  pibo tui:sessions [options]
+
+Options:
+  --session <id>       Open a specific Pibo session id
+  --max-rows <count>   Limit rendered transcript rows (default: 20)
+  --demo               Use deterministic fake session data for smoke testing
+  -h, --help           Show this help
+
+V2 commands inside the app:
+  ${cliCommandSummaryText()}
+
+Scope:
+  CLI Sessions is a reduced session/chat UI for SSH, bootstrap, recovery, and quick local work.
+  It starts only when stdin and stdout are interactive TTYs; pipes fail with a clear error.
+  Transcript rendering uses a bounded default tail window of 20 rows and truncates narrow terminal lines.
+  Web Chat remains the full control center for projects, workflows, Cron, Ralph, Agent Designer, settings, and context management.
+
+Related existing commands:
+  pibo tui
+  pibo tui:routed
+`;
+}

package/dist/apps/cli-ui/index.js

@@ -0,0 +1,8 @@
+export * from "./InkTerminalLine.js";
+export * from "./InkTerminalRow.js";
+export * from "./InkTerminalView.js";
+export * from "./InkSessionApp.js";
+export * from "./cliSessionsCommand.js";
+export * from "./inkColors.js";
+export * from "./inkJson.js";
+export * from "./inkMarkdown.js";