@pasko70/pibo 1.9.9 → 1.9.10

package/dist/session-ui/commandCatalog.js

@@ -0,0 +1,193 @@
+import { redactTerminalSecret } from "./statusViewModel.js";
+export const CLI_ONLY_SLASH_COMMANDS = [
+    { id: "help", slash: "/help", description: "Show command help and keyboard controls.", group: "cli", support: "supported" },
+    { id: "new", slash: "/new", description: "Create a new session in the active or selected room.", group: "navigation", support: "supported" },
+    { id: "room", slash: "/room", description: "Select the active room in the app context.", group: "navigation", support: "supported" },
+    { id: "session", slash: "/session", description: "Select a room, then open or create a session.", group: "navigation", support: "supported" },
+    { id: "agent", slash: "/agent", description: "Select an existing agent/profile for the session.", group: "navigation", support: "supported" },
+    { id: "profile", slash: "/profile", description: "Select an existing agent/profile for the session.", group: "navigation", support: "supported" },
+    { id: "repair-user-unknown", slash: "/repair-user-unknown", description: "Repair legacy CLI sessions stored under user:unknown.", group: "cli", support: "supported" },
+    { id: "exit", slash: "/exit", description: "Exit the terminal UI.", group: "cli", support: "supported", aliases: ["/quit"] },
+    { id: "quit", slash: "/quit", description: "Exit the terminal UI.", group: "cli", support: "supported" },
+];
+export const WEB_PARITY_SLASH_COMMANDS = [
+    { id: "status", slash: "/status", actionName: "status", description: "Show session, runtime, model, queue, and usage status.", group: "session", support: "supported" },
+    { id: "compact", slash: "/compact", actionName: "compact", description: "Run session compaction when the runtime supports it.", group: "runtime", support: "terminal-adapted" },
+    { id: "clear", slash: "/clear", actionName: "clear_queue", description: "Clear queued messages that have not started yet; terminal currently also clears local display.", group: "runtime", support: "terminal-adapted" },
+    { id: "abort", slash: "/abort", actionName: "abort", description: "Abort the active response.", group: "runtime", support: "terminal-adapted" },
+    { id: "kill", slash: "/kill", actionName: "kill", description: "Dispose the active session runtime.", group: "runtime", support: "terminal-adapted" },
+    { id: "kill-all", slash: "/kill-all", actionName: "kill-all", description: "Dispose all routed runtimes for the selected app context when supported.", group: "runtime", support: "terminal-adapted" },
+    { id: "fast", slash: "/fast", actionName: "fast_mode", description: "Toggle fast mode for the active session.", argumentHint: "[on|off]", group: "runtime", support: "terminal-adapted" },
+    { id: "thinking", slash: "/thinking", actionName: "thinking", description: "Show or set model thinking level.", argumentHint: "[off|minimal|low|medium|high|xhigh|max]", group: "runtime", support: "terminal-adapted", terminalAdaptation: "Without an argument, open a keyboard picker." },
+    { id: "model", slash: "/model", actionName: "model", description: "Choose an authenticated provider model.", group: "runtime", support: "terminal-adapted", terminalAdaptation: "Open provider and model pickers." },
+    { id: "login", slash: "/login", actionName: "login", description: "Authenticate a model provider.", group: "runtime", support: "terminal-adapted", terminalAdaptation: "Show provider/auth-method instructions in terminal." },
+    { id: "session-current", slash: "/session-current", actionName: "session-current", description: "Show metadata for the active session.", group: "session", support: "terminal-adapted" },
+    { id: "sessions", slash: "/sessions", actionName: "sessions", description: "List sessions for the selected shared room.", group: "session", support: "terminal-adapted" },
+    { id: "clone", slash: "/clone", actionName: "clone", description: "Clone or derive the active session when supported.", group: "session", support: "terminal-adapted" },
+    { id: "fork-candidates", slash: "/fork-candidates", actionName: "session.fork_candidates", description: "Inspect terminal-selectable fork candidates.", argumentHint: "[entry-id]", group: "session", support: "terminal-adapted", terminalAdaptation: "Without an argument, list candidates; selecting one attempts a routed fork." },
+    { id: "download", slash: "/download", actionName: "download", description: "Show terminal-safe download instructions for a server path.", argumentHint: "<path>", group: "session", support: "terminal-adapted", terminalAdaptation: "Use shell/server paths instead of browser download APIs." },
+    { id: "upload", slash: "/upload", actionName: "upload", description: "Show terminal-safe upload instructions for a local path.", argumentHint: "<path>", group: "session", support: "terminal-adapted", terminalAdaptation: "Use path-based terminal instructions instead of browser file picker APIs." },
+    { id: "thinking-show", slash: "/thinking-show", actionName: "thinking", description: "Show thinking controls in Web.", group: "unsupported", support: "deferred", unsupportedReason: "Use /thinking in terminal." },
+];
+export function buildSlashCommandCatalog(capabilities = []) {
+    const bySlash = new Map();
+    for (const command of [...WEB_PARITY_SLASH_COMMANDS, ...CLI_ONLY_SLASH_COMMANDS])
+        bySlash.set(command.slash, command);
+    for (const capability of expandGatewayCommandCapabilities(capabilities)) {
+        if (capability.hidden)
+            continue;
+        const slash = normalizeSlash(capability.slash ?? capability.name);
+        if (!slash)
+            continue;
+        const existing = bySlash.get(slash);
+        if (existing && isCliOwnedCommand(existing) && capability.name !== undefined)
+            continue;
+        bySlash.set(slash, {
+            id: slash.slice(1),
+            slash,
+            actionName: capability.actionName ?? existing?.actionName ?? capability.name,
+            description: redactTerminalSecret(capability.description ?? existing?.description ?? `Run ${slash}.`),
+            argumentHint: capability.argumentHint ?? existing?.argumentHint,
+            group: capability.browserOnly || capability.productArea ? "unsupported" : existing?.group ?? "session",
+            support: supportForCapability(capability, existing),
+            unsupportedReason: redactTerminalSecret(capability.unsupportedReason ?? existing?.unsupportedReason ?? "") || undefined,
+            terminalAdaptation: existing?.terminalAdaptation,
+            aliases: existing?.aliases,
+        });
+    }
+    return [...bySlash.values()].sort((left, right) => left.slash.localeCompare(right.slash));
+}
+export function filterSlashCommands(catalog, input) {
+    const normalized = input.trim().split(/\s+/, 1)[0]?.toLowerCase() ?? "";
+    const prefix = normalized.startsWith("/") ? normalized : `/${normalized}`;
+    return catalog.filter((command) => command.slash.toLowerCase().startsWith(prefix) || command.aliases?.some((alias) => alias.toLowerCase().startsWith(prefix)));
+}
+export function formatSlashCommand(command) {
+    return `${command.slash}${command.argumentHint ? ` ${command.argumentHint}` : ""}`;
+}
+export function commandSupportLabel(command) {
+    if (command.support === "supported")
+        return "available";
+    if (command.support === "terminal-adapted")
+        return "terminal";
+    if (command.support === "browser-only")
+        return "browser-only";
+    if (command.support === "product-area")
+        return "product-area";
+    return "deferred";
+}
+export function groupSlashCommandsForHelp(catalog) {
+    return {
+        available: catalog.filter((command) => (command.group === "session" || command.group === "runtime") && (command.support === "supported" || command.support === "terminal-adapted")),
+        navigation: catalog.filter((command) => command.group === "navigation" || command.group === "cli"),
+        unsupported: catalog.filter((command) => command.group === "unsupported" || command.support === "browser-only" || command.support === "product-area" || command.support === "deferred"),
+    };
+}
+export function buildSlashCommandBehaviorMatrix(catalog = buildSlashCommandCatalog()) {
+    return catalog.map((command) => ({
+        id: command.id,
+        slash: command.slash,
+        aliases: command.aliases ?? [],
+        group: command.group,
+        support: command.support,
+        supportLabel: commandSupportLabel(command),
+        palette: "shown",
+        argumentBehavior: slashArgumentBehavior(command),
+        enterBehavior: slashEnterBehavior(command),
+        resultPlacement: slashResultPlacement(command),
+        contextRequirement: slashContextRequirement(command),
+        errorBehavior: slashErrorBehavior(command),
+        terminalAdaptation: command.terminalAdaptation,
+    }));
+}
+function slashArgumentBehavior(command) {
+    if (command.argumentHint)
+        return command.argumentHint;
+    if (command.slash === "/model")
+        return "no argument opens provider/model picker; provider/model applies selection";
+    if (command.slash === "/login")
+        return "no argument opens provider/auth picker; provider/method applies selection";
+    if (command.slash === "/thinking")
+        return "no argument opens thinking picker; level applies selection";
+    return "none";
+}
+function slashEnterBehavior(command) {
+    if (command.slash === "/help")
+        return "append help text above transcript guidance";
+    if (command.slash === "/new")
+        return "create session in active or selected room";
+    if (["/room", "/session", "/profile", "/agent"].includes(command.slash))
+        return "open keyboard picker overlay";
+    if (["/exit", "/quit"].includes(command.slash))
+        return "exit terminal UI";
+    if (command.slash === "/repair-user-unknown")
+        return "append compact repair result";
+    if (["/model", "/login", "/thinking"].includes(command.slash))
+        return "open picker without arguments or append result with arguments";
+    if (command.slash === "/fork-candidates")
+        return "open candidate picker without entry id or dispatch fork with entry id";
+    if (command.support === "browser-only" || command.support === "product-area" || command.support === "deferred")
+        return "append unsupported/deferred transcript result";
+    return "append command and result rows to transcript";
+}
+function slashResultPlacement(command) {
+    if (["/exit", "/quit"].includes(command.slash))
+        return "exit";
+    if (["/room", "/session", "/profile", "/agent"].includes(command.slash))
+        return "overlay";
+    if (command.slash === "/new")
+        return "navigation";
+    if (["/model", "/login", "/thinking", "/fork-candidates"].includes(command.slash))
+        return "transcript-or-overlay";
+    return "transcript";
+}
+function slashContextRequirement(command) {
+    if (["/room", "/session", "/new", "/profile", "/repair-user-unknown"].includes(command.slash))
+        return "app room/session navigation";
+    if (["/status", "/sessions", "/session-current", "/clone", "/fork-candidates"].includes(command.slash))
+        return "active session when available; named room context preferred";
+    if (["/compact", "/clear", "/abort", "/kill", "/kill-all", "/fast", "/thinking", "/model", "/login"].includes(command.slash))
+        return "active routed session/runtime";
+    if (["/download", "/upload"].includes(command.slash))
+        return "terminal path argument";
+    return "none";
+}
+function slashErrorBehavior(command) {
+    if (command.support === "browser-only" || command.support === "product-area" || command.support === "deferred")
+        return "render compact unsupported result";
+    if (["/room", "/session", "/profile", "/agent", "/model", "/login", "/thinking", "/fork-candidates"].includes(command.slash))
+        return "keep overlay compact or append redacted error row after confirmed action";
+    return "append redacted command error row";
+}
+function expandGatewayCommandCapabilities(capabilities) {
+    const expanded = [];
+    for (const capability of capabilities) {
+        if (capability.slashCommands && capability.slashCommands.length > 0) {
+            for (const slash of capability.slashCommands)
+                expanded.push({ ...capability, slash, actionName: capability.actionName ?? capability.name });
+            continue;
+        }
+        expanded.push(capability);
+    }
+    return expanded;
+}
+function isCliOwnedCommand(command) {
+    return command.group === "cli" || command.slash === "/new" || command.slash === "/room" || command.slash === "/session" || command.slash === "/agent" || command.slash === "/profile";
+}
+function normalizeSlash(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed)
+        return undefined;
+    return (trimmed.startsWith("/") ? trimmed : `/${trimmed}`);
+}
+function supportForCapability(capability, existing) {
+    if (capability.browserOnly)
+        return "browser-only";
+    if (capability.productArea)
+        return "product-area";
+    if (capability.supported === false)
+        return "deferred";
+    return existing?.support ?? "terminal-adapted";
+}

package/dist/session-ui/commandResults.js

@@ -0,0 +1,95 @@
+import { redactTerminalSecret } from "./statusViewModel.js";
+export function normalizeCommandResultDescriptor(command, value) {
+    const unwrapped = unwrapActionPayload(value);
+    if (unwrapped instanceof Error)
+        return { kind: "error", title: command, message: redactTerminalSecret(unwrapped.message) };
+    if (typeof unwrapped === "string")
+        return { kind: "text", title: command, text: redactTerminalSecret(unwrapped) };
+    if (!unwrapped || typeof unwrapped !== "object" || Array.isArray(unwrapped))
+        return { kind: "json", title: command, value: unwrapped };
+    const record = unwrapped;
+    if (typeof record.error === "string")
+        return { kind: "error", title: command, message: redactTerminalSecret(record.error) };
+    if (record.supported === false || typeof record.unsupportedReason === "string") {
+        return { kind: "unsupported", command, reason: redactTerminalSecret(typeof record.unsupportedReason === "string" ? record.unsupportedReason : "This command is not supported in the terminal.") };
+    }
+    if (command === "status" || record.contextUsage || record.providerUsage || record.queuedMessages !== undefined) {
+        return { kind: "status", title: "Status", status: record };
+    }
+    if (typeof record.piboSessionId === "string" || typeof record.sessionId === "string") {
+        return {
+            kind: "session-link",
+            title: command,
+            sessionId: String(record.piboSessionId ?? record.sessionId),
+            roomId: typeof record.roomId === "string" ? record.roomId : undefined,
+            roomLabel: typeof record.roomTitle === "string" ? redactTerminalSecret(record.roomTitle) : typeof record.roomLabel === "string" ? redactTerminalSecret(record.roomLabel) : undefined,
+            label: typeof record.title === "string" ? redactTerminalSecret(record.title) : typeof record.sessionTitle === "string" ? redactTerminalSecret(record.sessionTitle) : undefined,
+        };
+    }
+    if (record.action === "show_login_menu" || record.action === "show_model_menu" || record.action === "show_fork_candidates" || Array.isArray(record.items) || Array.isArray(record.providers) || Array.isArray(record.messages)) {
+        return { kind: "menu", title: menuTitle(command, record), items: menuItems(record) };
+    }
+    if (typeof record.message === "string")
+        return { kind: "text", title: command, text: redactTerminalSecret(record.message), tone: record.ok === false ? "red" : "green" };
+    return { kind: "json", title: command, value: record };
+}
+export function normalizeCommandErrorDescriptor(command, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { kind: "error", title: command, message: redactTerminalSecret(message) };
+}
+function unwrapActionPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const record = value;
+    if (record.ok === true && "result" in record)
+        return record.result;
+    if (record.success === true && "data" in record)
+        return record.data;
+    return value;
+}
+function menuTitle(command, record) {
+    if (record.action === "show_login_menu")
+        return "Login";
+    if (record.action === "show_model_menu")
+        return "Model";
+    if (record.action === "show_fork_candidates")
+        return "Fork candidates";
+    return command;
+}
+function menuItems(record) {
+    const explicitItems = arrayRecordField(record, "items");
+    if (explicitItems.length)
+        return explicitItems.map((item, index) => itemFromRecord(item, index));
+    const providers = arrayRecordField(record, "providers");
+    if (providers.length)
+        return providers.map((provider, index) => itemFromRecord(provider, index));
+    const messages = arrayRecordField(record, "messages");
+    return messages.map((message, index) => itemFromRecord(message, index));
+}
+function itemFromRecord(record, index) {
+    const id = stringField(record, "id") ?? stringField(record, "entryId") ?? stringField(record, "provider") ?? `item-${index}`;
+    const text = stringField(record, "text");
+    return {
+        id,
+        label: redactTerminalSecret(stringField(record, "label") ?? stringField(record, "name") ?? trimLabel(text) ?? id),
+        description: redactTerminalSecret(stringField(record, "description") ?? (text && text.length > 80 ? text : undefined) ?? stringField(record, "reason") ?? arrayStringField(record, "authMethods").join(", ")) || undefined,
+        action: stringField(record, "action"),
+        value: record.value ?? record,
+        disabled: record.disabled === true,
+    };
+}
+function arrayRecordField(record, key) {
+    const value = record[key];
+    return Array.isArray(value) ? value.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)) : [];
+}
+function arrayStringField(record, key) {
+    const value = record[key];
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function trimLabel(value) {
+    return value;
+}

package/dist/session-ui/delegation.js

@@ -0,0 +1,89 @@
+export function resolveAgentDelegationStatus(childSignal, fallbackStatus = "done", traceTerminal = false) {
+    if (!childSignal)
+        return fallbackStatus === "running" ? "running" : fallbackStatus === "error" ? "failed" : "completed";
+    if (traceTerminal)
+        return fallbackStatus === "error" ? "failed" : "completed";
+    const statuses = [childSignal.localStatus, childSignal.aggregateStatus];
+    if (statuses.some(isCancelledSignalStatus))
+        return "cancelled";
+    if (childSignal.hasError || childSignal.hasErrorDescendant || statuses.some(isFailedSignalStatus))
+        return "failed";
+    if (childSignal.isSettled === false || childSignal.isTreeActive || childSignal.isLocalActive || childSignal.hasActiveDescendant || statuses.some(isRunningSignalStatus))
+        return "running";
+    if (fallbackStatus === "running" && statuses.every(isIdleSignalStatus))
+        return "running";
+    return "completed";
+}
+export function extractAgentDelegationName(input, title, summary) {
+    const record = isRecord(input) ? input : undefined;
+    const rawName = stringValue(record?.subagentName)
+        ?? subagentNameFromToolName(title)
+        ?? stringValue(summary)
+        ?? stringValue(title)
+        ?? "Subagent";
+    return titleCaseAgentName(rawName);
+}
+export function extractAgentDelegationTask(input) {
+    if (typeof input === "string")
+        return nonEmpty(input);
+    if (!isRecord(input))
+        return undefined;
+    for (const key of ["message", "task", "prompt", "query"]) {
+        const value = nonEmpty(input[key]);
+        if (value)
+            return value;
+    }
+    return extractAgentDelegationTask(input.arguments);
+}
+export function compactAgentDelegationTask(input, maxLength = 180) {
+    const task = extractAgentDelegationTask(input)?.replace(/\s+/g, " ").trim();
+    if (!task || maxLength < 1)
+        return undefined;
+    return task.length <= maxLength ? task : `${task.slice(0, Math.max(1, maxLength - 1)).trimEnd()}…`;
+}
+export function formatAgentDelegationDuration(durationMs) {
+    const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+    if (totalSeconds < 60)
+        return `${totalSeconds}s`;
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m ${seconds}s`;
+    return `${minutes}m ${seconds}s`;
+}
+function isRunningSignalStatus(status) {
+    return ["queued", "starting", "running", "streaming", "waiting", "blocked", "retrying", "compacting", "pausing", "paused"].includes(status);
+}
+function isIdleSignalStatus(status) {
+    return status === "idle" || status === "unknown";
+}
+function isFailedSignalStatus(status) {
+    return status === "error";
+}
+function isCancelledSignalStatus(status) {
+    return status === "cancelled" || status === "interrupted" || status === "disposed";
+}
+function subagentNameFromToolName(value) {
+    const name = nonEmpty(value);
+    if (!name)
+        return undefined;
+    return name.replace(/^pibo_subagent_/, "");
+}
+function titleCaseAgentName(value) {
+    return value
+        .replace(/^pibo_subagent_/, "")
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+        .join(" ") || "Subagent";
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function stringValue(value) {
+    return nonEmpty(value);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/session-ui/index.js

@@ -0,0 +1,8 @@
+export * from "./commandCatalog.js";
+export * from "./commandResults.js";
+export * from "./delegation.js";
+export * from "./roomSessionViewModel.js";
+export * from "./statusViewModel.js";
+export * from "./terminalCards.js";
+export * from "./terminalRows.js";
+export * from "./terminalValue.js";

package/dist/session-ui/roomSessionViewModel.js

@@ -0,0 +1,69 @@
+import { redactTerminalSecret } from "./statusViewModel.js";
+export function buildRoomPickerDescriptor(input) {
+    const items = input.rooms.map((room) => roomPickerItem(room, room.id === input.activeRoomId, room.id === input.defaultRoomId || room.isDefault === true));
+    const activeIndex = items.findIndex((item) => item.active);
+    const defaultIndex = items.findIndex((item) => item.default);
+    const selectedIndex = Math.max(0, activeIndex >= 0 ? activeIndex : defaultIndex);
+    return {
+        kind: "room",
+        title: input.title ?? "Select room",
+        items,
+        selectedIndex,
+        emptyMessage: "No rooms are available.",
+    };
+}
+export function buildSessionPickerDescriptor(input) {
+    const roomTitle = redactTerminalSecret(input.room.title ?? input.room.id);
+    const backItem = input.includeBackAction ? [{ id: "back", kind: "back", label: "← Back to rooms", markers: [] }] : [];
+    const sessionItems = input.sessions.map((session) => sessionPickerItem(session, session.id === input.activeSessionId));
+    const createItem = input.includeCreateAction === false ? [] : [{
+            id: `create:${input.room.id}`,
+            kind: "create-session",
+            label: `+ New session in ${roomTitle}`,
+            description: "Create and open a new CLI session in this room",
+            roomId: input.room.id,
+            markers: ["new"],
+        }];
+    const items = [...backItem, ...sessionItems, ...createItem];
+    const selectedIndex = Math.max(0, items.findIndex((item) => item.current || item.kind === "create-session"));
+    return {
+        kind: "session",
+        title: input.title ?? `Select session in ${roomTitle}`,
+        items,
+        selectedIndex,
+        emptyMessage: `No sessions in ${roomTitle}. Create a new session to start chatting.`,
+        roomId: input.room.id,
+    };
+}
+function roomPickerItem(room, active, isDefault) {
+    const markers = [active ? "active" : undefined, isDefault ? "default" : undefined, room.archived ? "archived" : undefined]
+        .filter((marker) => Boolean(marker));
+    return {
+        id: room.id,
+        kind: "room",
+        label: redactTerminalSecret(room.title ?? room.id),
+        description: redactTerminalSecret([room.description, markers.join(", ")].filter(Boolean).join(" | ")) || undefined,
+        roomId: room.id,
+        active,
+        default: isDefault,
+        archived: room.archived,
+        disabled: room.disabled,
+        markers,
+    };
+}
+function sessionPickerItem(session, current) {
+    const markers = [current ? "current" : undefined, session.status, session.archived ? "archived" : undefined]
+        .filter((marker) => Boolean(marker));
+    return {
+        id: session.id,
+        kind: "session",
+        label: redactTerminalSecret(session.title ?? session.id),
+        description: redactTerminalSecret([session.profile, session.description, session.updatedAt, markers.join(", ")].filter(Boolean).join(" | ")) || undefined,
+        roomId: session.roomId,
+        sessionId: session.id,
+        current,
+        archived: session.archived,
+        disabled: session.disabled,
+        markers,
+    };
+}

package/dist/session-ui/sessionActivity.js

@@ -0,0 +1,30 @@
+export function resolveSessionActivity(signal, fallback = {}) {
+    if (!signal)
+        return fallbackSessionActivity(fallback);
+    const latestTurn = signal.latestTurn;
+    const isTurnActive = latestTurn?.state === "running";
+    const isTreeActive = signal.isTreeActive || isTurnActive;
+    const hasError = signal.hasError || signal.hasErrorDescendant || signal.aggregateStatus === "error";
+    return {
+        status: hasError ? "error" : isTreeActive ? "running" : "idle",
+        isTreeActive,
+        isTurnActive,
+        activeTurnId: isTurnActive ? latestTurn.eventId : undefined,
+        activeTurnStartedAt: isTurnActive ? latestTurn.startedAt : undefined,
+        latestTurn,
+        source: "signals",
+    };
+}
+function fallbackSessionActivity(fallback) {
+    const isTurnActive = fallback.status === "running" && validTimestamp(fallback.turnStartedAt);
+    return {
+        status: fallback.status ?? "idle",
+        isTreeActive: fallback.status === "running",
+        isTurnActive,
+        activeTurnStartedAt: isTurnActive ? fallback.turnStartedAt : undefined,
+        source: "fallback",
+    };
+}
+function validTimestamp(value) {
+    return Boolean(value && Number.isFinite(Date.parse(value)));
+}

package/dist/session-ui/statusViewModel.js

@@ -0,0 +1,127 @@
+export function buildTerminalStatusViewModel(input = {}) {
+    const fields = [];
+    const progress = [];
+    const warnings = sanitizeTextList(input.warnings);
+    const errors = sanitizeTextList(input.errors);
+    if (input.session?.id || input.session?.title) {
+        fields.push({ id: "session", label: "Session", value: redactTerminalSecret([input.session?.title, input.session?.id].filter(Boolean).join(" | ")) });
+    }
+    if (input.session?.profile)
+        fields.push({ id: "profile", label: "Profile", value: redactTerminalSecret(input.session.profile) });
+    if (input.session?.status)
+        fields.push({ id: "session-status", label: "Session status", value: redactTerminalSecret(input.session.status), tone: input.session.status === "error" || input.session.status === "disposed" ? "red" : "neutral" });
+    if (input.model?.provider || input.model?.id || input.model?.label) {
+        fields.push({ id: "model", label: "Model", value: redactTerminalSecret(input.model.label ?? [input.model.provider, input.model.id].filter(Boolean).join("/")) });
+    }
+    if (input.runtime?.state)
+        fields.push({ id: "runtime", label: "Runtime", value: redactTerminalSecret(input.runtime.state), tone: input.runtime.connected === false || input.runtime.disposed ? "red" : "green" });
+    if (input.runtime?.disposed !== undefined)
+        fields.push({ id: "disposed", label: "Disposed", value: input.runtime.disposed ? "yes" : "no", tone: input.runtime.disposed ? "red" : "neutral" });
+    if (typeof input.runtime?.queuedMessages === "number")
+        fields.push({ id: "queue", label: "Queue", value: String(input.runtime.queuedMessages) });
+    if (input.runtime?.processing !== undefined)
+        fields.push({ id: "processing", label: "Processing", value: input.runtime.processing ? "yes" : "no", tone: input.runtime.processing ? "cyan" : "neutral" });
+    if (input.runtime?.streaming !== undefined)
+        fields.push({ id: "streaming", label: "Streaming", value: input.runtime.streaming ? "yes" : "no", tone: input.runtime.streaming ? "cyan" : "neutral" });
+    if (input.cwd)
+        fields.push({ id: "cwd", label: "CWD", value: redactTerminalSecret(input.cwd) });
+    const thinking = typeof input.thinking === "string" ? { level: input.thinking } : input.thinking;
+    if (thinking?.level || thinking?.supported !== undefined) {
+        fields.push({ id: "thinking", label: "Thinking", value: redactTerminalSecret(thinking.level ?? (thinking.supported === false ? "unsupported" : "available")), tone: thinking.supported === false ? "red" : "yellow" });
+    }
+    if (input.fastMode !== undefined)
+        fields.push({ id: "fast-mode", label: "Fast mode", value: typeof input.fastMode === "string" ? redactTerminalSecret(input.fastMode) : input.fastMode ? "on" : "off", tone: input.fastMode ? "green" : "neutral" });
+    const enabledTools = sanitizeTextList(input.tools?.enabled);
+    const activeTools = sanitizeTextList(input.tools?.active);
+    if (enabledTools.length)
+        fields.push({ id: "enabled-tools", label: "Enabled tools", value: `${enabledTools.length}${enabledTools.length <= 4 ? ` (${enabledTools.join(", ")})` : ""}` });
+    if (activeTools.length)
+        fields.push({ id: "active-tools", label: "Active tools", value: `${activeTools.length}${activeTools.length <= 4 ? ` (${activeTools.join(", ")})` : ""}`, tone: "cyan" });
+    if (input.providerUsage?.planType)
+        fields.push({ id: "provider-plan", label: "Provider plan", value: redactTerminalSecret(input.providerUsage.planType) });
+    if (input.providerUsage?.credits)
+        fields.push({ id: "provider-credits", label: "Credits", value: input.providerUsage.credits.unlimited ? "unlimited" : redactTerminalSecret(input.providerUsage.credits.balance ?? "available") });
+    if (input.message)
+        fields.push({ id: "message", label: "Message", value: redactTerminalSecret(input.message) });
+    progress.push(contextProgress(input.contextUsage));
+    for (const descriptor of providerProgress(input.providerUsage))
+        progress.push(descriptor);
+    return { kind: "status", title: "Status", fields, progress, warnings, errors };
+}
+export function progressBarText(descriptor, width = 20) {
+    if (descriptor.state === "unavailable" || descriptor.percent === undefined)
+        return "unavailable";
+    const boundedWidth = Math.max(4, Math.min(80, Math.floor(width)));
+    const filled = Math.round((Math.max(0, Math.min(100, descriptor.percent)) / 100) * boundedWidth);
+    return `${"█".repeat(filled)}${"░".repeat(boundedWidth - filled)} ${descriptor.percent.toFixed(1)}%`;
+}
+export function redactTerminalSecret(text) {
+    return text
+        .replace(/\b([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD)[A-Z0-9_]*)\s*=\s*([^\s]+)/gi, "$1=[redacted]")
+        .replace(/\b(api[_-]?key|token|secret|password)\s*[:=]\s*([^\s]+)/gi, "$1=[redacted]")
+        .replace(/\b(?:sk|pk|pibo|ghp|github_pat)_[A-Za-z0-9_\-]{8,}\b/g, "[redacted]");
+}
+function contextProgress(usage) {
+    if (!usage || (usage.tokens === undefined && usage.contextWindow === undefined && usage.percent === undefined)) {
+        return { id: "context", label: "Context", state: "unavailable", text: "Context usage unavailable", tone: "neutral" };
+    }
+    const percent = normalizePercent(usage.percent ?? (usage.tokens !== undefined && usage.contextWindow ? (usage.tokens / usage.contextWindow) * 100 : undefined));
+    return {
+        id: "context",
+        label: "Context",
+        state: percent === undefined ? "unavailable" : "available",
+        value: usage.tokens,
+        max: usage.contextWindow,
+        percent,
+        text: percent === undefined ? "Context usage unavailable" : `${usage.tokens ?? "?"}/${usage.contextWindow ?? "?"} tokens (${percent.toFixed(1)}%)`,
+        tone: toneForPercent(percent),
+    };
+}
+function providerProgress(usage) {
+    if (!usage?.limits?.length) {
+        return [{ id: "provider", label: "Provider quota", state: "unavailable", text: "Provider usage unavailable", tone: "neutral" }];
+    }
+    return usage.limits.map((limit, index) => {
+        const usedPercent = normalizePercent(limit.usedPercent);
+        const remainingPercent = normalizePercent(limit.remainingPercent ?? (usedPercent === undefined ? undefined : 100 - usedPercent));
+        const provider = usage.provider ? `${usage.provider} ` : "";
+        const details = [
+            remainingPercent === undefined ? undefined : `${remainingPercent.toFixed(1)}% remaining`,
+            limit.resetsAt ? `resets ${redactTerminalSecret(limit.resetsAt)}` : undefined,
+        ].filter(Boolean).join(", ");
+        return {
+            id: `provider-${index}`,
+            label: `${provider}${limit.label ?? "quota"}`.trim(),
+            state: remainingPercent === undefined ? "unavailable" : "available",
+            percent: remainingPercent,
+            text: remainingPercent === undefined ? "Provider usage unavailable" : details,
+            tone: toneForRemainingPercent(remainingPercent),
+        };
+    });
+}
+function normalizePercent(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    return Math.max(0, Math.min(100, value));
+}
+function toneForPercent(percent) {
+    if (percent === undefined)
+        return "neutral";
+    if (percent >= 80)
+        return "red";
+    if (percent >= 50)
+        return "yellow";
+    return "green";
+}
+function toneForRemainingPercent(percent) {
+    if (percent === undefined)
+        return "neutral";
+    if (percent <= 20)
+        return "red";
+    if (percent <= 50)
+        return "yellow";
+    return "green";
+}
+function sanitizeTextList(values) {
+    return (values ?? []).map((value) => redactTerminalSecret(value)).filter((value) => value.length > 0);
+}