@pasko70/pibo 1.9.8 → 1.9.9

package/dist/cli-session/localSessionSource.js

@@ -1,1144 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { DEFAULT_PIBO_PROFILE_NAME, createDefaultPiboPluginRegistry, resolvePiboProfileNameFromRegistryOrDefault, } from "../plugins/builtin.js";
-import { createDefaultPiboDataSessionStore } from "../sessions/pibo-data-store.js";
-import { getDefaultPiboWorkspace } from "../core/workspace.js";
-import { buildTraceView } from "../apps/chat/trace.js";
-import { storedPiboEventFromV2Row, } from "../apps/chat/data/chat-data-mappers.js";
-import { ChatDataIngestService } from "../data/ingest-service.js";
-import { ChatRoomService } from "../apps/chat/data/room-service.js";
-import { buildSlashCommandCatalog, normalizeCommandErrorDescriptor, normalizeCommandResultDescriptor, } from "../session-ui/index.js";
-import { CliSourceError, } from "./sessionSource.js";
-export const CLI_LOCAL_RECOVERY_SOURCE_ID = "local:root";
-export const CLI_LOCAL_RECOVERY_SOURCE_LABEL = "Local recovery";
-export class LocalCliSessionSource {
-    sessionStore;
-    ownsSessionStore;
-    roomProvider;
-    pluginRegistry;
-    router;
-    ownsRouter;
-    unsubscribeRouter;
-    now;
-    statusMessage;
-    dataStore;
-    ownsDataStore;
-    ingestService;
-    roomService;
-    agentSummaries;
-    traceViews = new Map();
-    listeners = new Map();
-    openHandles = new Set();
-    closed = false;
-    constructor(options = {}) {
-        this.sessionStore =
-            options.sessionStore ?? createDefaultPiboDataSessionStore();
-        this.ownsSessionStore =
-            options.ownsSessionStore ?? options.sessionStore === undefined;
-        this.roomProvider = options.roomProvider;
-        this.pluginRegistry =
-            options.pluginRegistry ?? createDefaultPiboPluginRegistry();
-        this.router = options.router;
-        this.ownsRouter = options.ownsRouter ?? false;
-        this.unsubscribeRouter = this.router?.subscribe((event) => this.handleRouterEvent(event));
-        this.now = options.now ?? (() => new Date().toISOString());
-        this.statusMessage = options.statusMessage;
-        this.dataStore = options.dataStore;
-        this.ownsDataStore = options.ownsDataStore === true;
-        this.ingestService = options.dataStore
-            ? new ChatDataIngestService(options.dataStore)
-            : undefined;
-        this.roomService = options.dataStore
-            ? new ChatRoomService(options.dataStore)
-            : undefined;
-        this.agentSummaries = options.agentSummaries
-            ? [...options.agentSummaries]
-            : undefined;
-    }
-    async listRooms() {
-        this.assertOpen();
-        if (this.roomProvider) {
-            return ensureDefaultRoomSummary((await this.roomProvider.listRooms()).map(cloneJson));
-        }
-        if (this.roomService) {
-            const defaultRoom = this.roomService.ensureDefaultRoom({
-                name: "Shared Chat",
-            });
-            const rooms = mergeRoomSummaries([
-                ...this.roomService.listRooms().map((room) => ({
-                    id: room.id,
-                    title: room.name,
-                    description: room.topic,
-                    isDefault: room.id === defaultRoom.id || room.metadata.default === true,
-                })),
-                ...deriveRoomsFromSessions(this.readSessions()),
-            ]);
-            return ensureDefaultRoomSummary(rooms).map(cloneJson);
-        }
-        return ensureDefaultRoomSummary(deriveRoomsFromSessions(this.readSessions())).map(cloneJson);
-    }
-    async listSessions(input = {}) {
-        this.assertOpen();
-        const defaultRoomId = this.ensureDefaultRoom().id;
-        return this.readSessions()
-            .filter((session) => input.roomId === undefined ||
-            roomIdFromSession(session, defaultRoomId) === input.roomId)
-            .map((session) => sessionToSummary(session, defaultRoomId));
-    }
-    async createSession(input = {}) {
-        this.assertOpen();
-        const agent = input.agentId ? this.resolveAgent(input.agentId) : undefined;
-        const profile = this.resolveProfile(input.profile ??
-            agent?.profileName ??
-            agent?.id ??
-            this.defaultProfileName());
-        const room = input.roomId
-            ? await this.findRoomSummary(input.roomId)
-            : this.ensureDefaultRoom();
-        const roomId = input.roomId ?? room?.id;
-        const metadata = buildSessionMetadata(roomId, "idle", room?.title);
-        const session = this.sessionStore.create({
-            channel: "cli-session-ui",
-            kind: "chat",
-            profile,
-            workspace: input.workspace ?? getDefaultPiboWorkspace(),
-            title: input.title?.trim() || "New CLI session",
-            metadata,
-        });
-        if (roomId)
-            this.upsertSessionNavigation(session, roomId, undefined, "idle");
-        this.traceViews.set(session.id, emptyTraceView(session));
-        const summary = sessionToSummary(session, this.ensureDefaultRoom().id);
-        this.emit(session.id, {
-            type: "session",
-            session: summary,
-            traceView: cloneJson(this.traceViews.get(session.id) ?? null),
-            status: await this.getStatus({ sessionId: session.id }),
-        });
-        return summary;
-    }
-    async openSession(sessionId) {
-        this.assertOpen();
-        const session = this.resolveSession(sessionId);
-        let handleClosed = false;
-        const handleListeners = new Set();
-        const removeFromSource = () => {
-            const sourceListeners = this.listeners.get(sessionId);
-            if (!sourceListeners)
-                return;
-            for (const listener of handleListeners)
-                sourceListeners.delete(listener);
-            if (sourceListeners.size === 0)
-                this.listeners.delete(sessionId);
-        };
-        const handle = {
-            sessionId,
-            close: () => {
-                if (handleClosed)
-                    return;
-                handleClosed = true;
-                removeFromSource();
-                this.openHandles.delete(handle);
-            },
-        };
-        this.openHandles.add(handle);
-        const traceView = await this.loadTraceView(session);
-        this.traceViews.set(sessionId, traceView);
-        return {
-            session: sessionToSummary(session, this.ensureDefaultRoom().id),
-            traceView: cloneJson(traceView),
-            status: await this.getStatus({ sessionId }),
-            subscribe: (listener) => {
-                if (handleClosed)
-                    throw new CliSourceError("session_closed", `CLI session handle for "${sessionId}" is closed`);
-                handleListeners.add(listener);
-                let sourceListeners = this.listeners.get(sessionId);
-                if (!sourceListeners) {
-                    sourceListeners = new Set();
-                    this.listeners.set(sessionId, sourceListeners);
-                }
-                sourceListeners.add(listener);
-                return () => {
-                    handleListeners.delete(listener);
-                    const listeners = this.listeners.get(sessionId);
-                    listeners?.delete(listener);
-                    if (listeners?.size === 0)
-                        this.listeners.delete(sessionId);
-                };
-            },
-            close: handle.close,
-        };
-    }
-    async sendMessage(sessionId, text) {
-        this.assertOpen();
-        const trimmed = text.trim();
-        if (!trimmed)
-            throw new CliSourceError("empty_message", "Message text is empty");
-        const session = this.resolveSession(sessionId);
-        const eventId = randomUUID();
-        this.ingestUserMessage(session, eventId, trimmed);
-        if (this.router) {
-            try {
-                await this.router.emit({
-                    type: "message",
-                    piboSessionId: sessionId,
-                    id: eventId,
-                    text: trimmed,
-                    source: "ui",
-                });
-            }
-            catch (error) {
-                this.recordLocalError(sessionId, eventId, error);
-                throw toCliSourceError("send_failed", `Failed to send local CLI message to session "${sessionId}"`, error);
-            }
-            return;
-        }
-        this.recordLocalUserMessage(sessionId, eventId, trimmed, "done");
-        this.updateSessionStatus(sessionId, "idle");
-    }
-    async listAgents() {
-        this.assertOpen();
-        if (this.agentSummaries)
-            return this.agentSummaries.map(cloneJson);
-        const agents = this.pluginRegistry.getProfileInfos().map((profile) => ({
-            id: profile.name,
-            name: profile.name,
-            description: profile.description,
-            profileName: profile.name,
-        }));
-        return agents.some((agent) => agent.profileName === DEFAULT_PIBO_PROFILE_NAME)
-            ? agents
-            : [defaultBaseAgentSummary(), ...agents];
-    }
-    async listSlashCommands() {
-        this.assertOpen();
-        return this.buildSlashCommands().map(cloneJson);
-    }
-    async executeSlashCommand(input) {
-        this.assertOpen();
-        const command = normalizeCommandName(input.command);
-        const descriptor = this.findSlashCommand(command);
-        const actionName = descriptor.actionName ?? descriptor.id;
-        const session = input.sessionId
-            ? this.resolveSession(input.sessionId)
-            : undefined;
-        if (descriptor.support === "browser-only" ||
-            descriptor.support === "product-area" ||
-            descriptor.support === "deferred") {
-            const rawResult = {
-                supported: false,
-                unsupportedReason: descriptor.unsupportedReason ??
-                    `${descriptor.slash} is not supported in the terminal.`,
-            };
-            return {
-                command,
-                actionName,
-                descriptor: normalizeCommandResultDescriptor(command, rawResult),
-                rawResult,
-            };
-        }
-        try {
-            const rawResult = await this.executeLocalSlashAction({
-                command,
-                actionName,
-                session,
-                args: input.args,
-            });
-            const openSessionId = sessionIdFromActionResult(rawResult);
-            const roomId = roomIdFromActionResult(rawResult) ??
-                (openSessionId
-                    ? roomIdFromSession(this.sessionStore.get(openSessionId) ??
-                        session ??
-                        {})
-                    : undefined);
-            if (openSessionId)
-                this.upsertDerivedSessionNavigation(openSessionId, roomId);
-            return {
-                command,
-                actionName,
-                descriptor: normalizeCommandResultDescriptor(command, rawResult),
-                rawResult,
-                openSessionId,
-                roomId,
-            };
-        }
-        catch (error) {
-            return {
-                command,
-                actionName,
-                descriptor: normalizeCommandErrorDescriptor(command, error),
-                rawResult: {
-                    error: error instanceof Error ? error.message : String(error),
-                },
-            };
-        }
-    }
-    async setSessionAgent(sessionId, agentId) {
-        this.assertOpen();
-        const session = this.resolveSession(sessionId);
-        const agent = this.resolveAgent(agentId);
-        if (agent.profileName === session.profile || agent.id === session.profile)
-            return sessionToSummary(session, this.ensureDefaultRoom().id);
-        throw new CliSourceError("unsupported", "Changing an existing local session profile is not supported by the CLI source. Use /new after selecting the desired profile, or start a new session with that profile.");
-    }
-    async repairLegacyCliSessions(input = {}) {
-        this.assertOpen();
-        const room = input.roomId
-            ? await this.findRoomSummary(input.roomId)
-            : this.ensureDefaultRoom();
-        const roomId = input.roomId ?? room?.id;
-        void input.sessionIds;
-        const candidates = [];
-        let repaired = 0;
-        const repairedIds = [];
-        for (const session of candidates) {
-            if (!isLegacyCliUnknownSession(session))
-                continue;
-            const status = statusFromSession(session) === "unknown"
-                ? "idle"
-                : statusFromSession(session);
-            const metadata = {
-                ...(session.metadata ?? {}),
-                ...buildSessionMetadata(roomId, status, room?.title),
-                repairedFromLegacyScope: "user:unknown",
-                repairedAt: this.now(),
-            };
-            const updated = this.sessionStore.update(session.id, { metadata }) ?? {
-                ...session,
-                metadata,
-                updatedAt: this.now(),
-            };
-            if (this.dataStore && roomId)
-                this.dataStore.sessions.upsertSession({
-                    session: updated,
-                    roomId,
-                    status,
-                    lastActivityAt: updated.updatedAt,
-                });
-            if (roomId)
-                this.upsertSessionNavigation(updated, roomId, undefined, status);
-            repaired += 1;
-            repairedIds.push(session.id);
-        }
-        return {
-            roomId,
-            scanned: candidates.length,
-            repaired,
-            skipped: candidates.length - repaired,
-            sessionIds: repairedIds,
-        };
-    }
-    async getStatus(input = {}) {
-        this.assertOpen();
-        if (input.sessionId) {
-            const session = this.resolveSession(input.sessionId);
-            return this.buildStatus(session);
-        }
-        const sessions = this.readSessions();
-        const rooms = this.roomProvider ? "supported" : "supported";
-        return {
-            source: "local/direct",
-            mode: "local",
-            connected: true,
-            rooms,
-            activeRoomId: this.ensureDefaultRoom().id,
-            sessions: "supported",
-            agents: "supported",
-            message: redactCliSecretText(this.statusMessage ??
-                `Local CLI source ready; discovered ${sessions.length} session${sessions.length === 1 ? "" : "s"}.`),
-            updatedAt: this.now(),
-        };
-    }
-    async close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        for (const handle of [...this.openHandles])
-            handle.close();
-        this.listeners.clear();
-        this.unsubscribeRouter?.();
-        if (this.ownsRouter)
-            await this.router?.disposeAll?.();
-        if (this.ownsSessionStore)
-            this.sessionStore.close?.();
-        if (this.ownsDataStore)
-            this.dataStore?.close();
-    }
-    listenerCount(sessionId) {
-        if (sessionId)
-            return this.listeners.get(sessionId)?.size ?? 0;
-        let count = 0;
-        for (const listeners of this.listeners.values())
-            count += listeners.size;
-        return count;
-    }
-    buildSlashCommands() {
-        return buildSlashCommandCatalog(this.pluginRegistry.getGatewayActionInfos().map((action) => ({
-            name: action.name,
-            description: action.description,
-            slashCommands: action.slashCommands,
-        })));
-    }
-    findSlashCommand(command) {
-        const slash = `/${command}`;
-        const descriptor = this.buildSlashCommands().find((candidate) => candidate.slash === slash ||
-            candidate.aliases?.includes(slash));
-        if (!descriptor)
-            throw new CliSourceError("unsupported", `No slash command found for /${command}`);
-        return descriptor;
-    }
-    async executeLocalSlashAction(input) {
-        if (input.command === "status") {
-            if (input.session && this.router) {
-                const event = {
-                    type: "execution",
-                    piboSessionId: input.session.id,
-                    action: input.actionName,
-                    id: randomUUID(),
-                };
-                const output = await this.router.emit(event);
-                if (output.type === "execution_result")
-                    return output.result;
-            }
-            const status = input.session
-                ? this.buildStatus(input.session)
-                : await this.getStatus();
-            return { ...status, activeModel: input.session?.activeModel };
-        }
-        if (input.command === "session-current") {
-            if (!input.session)
-                return { supported: false, unsupportedReason: "No session is open." };
-            const defaultRoomId = this.ensureDefaultRoom().id;
-            const roomId = roomIdFromSession(input.session, defaultRoomId);
-            const room = roomId ? await this.findRoomSummary(roomId) : undefined;
-            return sessionMetadataResult(input.session, defaultRoomId, room?.title);
-        }
-        if (input.command === "sessions") {
-            const roomId = input.session
-                ? roomIdFromSession(input.session, this.ensureDefaultRoom().id)
-                : undefined;
-            const rooms = new Map((await this.listRooms()).map((room) => [room.id, room]));
-            return (await this.listSessions({ roomId })).map((session) => ({
-                id: session.id,
-                title: session.title,
-                sessionTitle: session.title,
-                roomId: session.roomId,
-                roomTitle: session.roomId
-                    ? rooms.get(session.roomId)?.title
-                    : undefined,
-                profile: session.profile,
-                status: session.status,
-                updatedAt: session.updatedAt,
-            }));
-        }
-        if (input.command === "download")
-            return terminalDownloadResult(input.args);
-        if (input.command === "upload")
-            return terminalUploadResult(input.args);
-        if (!input.session)
-            return {
-                supported: false,
-                unsupportedReason: `/${input.command} requires an open session.`,
-            };
-        if (input.command === "login" &&
-            loginAuthMethodFromArgs(input.args) === "api_key")
-            return terminalApiKeyLoginInstructions(input.args);
-        if (!this.router) {
-            return {
-                supported: false,
-                unsupportedReason: `/${input.command} requires a routed local runtime. Open a local routed session or use a debug PTY mocked router.`,
-            };
-        }
-        const action = routedActionNameForSlash(input.command, input.actionName, input.args);
-        const params = executionParamsForSlash(input.command, input.args);
-        const event = {
-            type: "execution",
-            piboSessionId: input.session.id,
-            action,
-            id: randomUUID(),
-            ...(params !== undefined ? { params } : {}),
-        };
-        const output = await this.router.emit(event);
-        if (output.type !== "execution_result")
-            throw new CliSourceError("action_failed", `Action /${input.command} did not return an execution result.`);
-        return output.result;
-    }
-    upsertDerivedSessionNavigation(sessionId, resultRoomId) {
-        const session = this.sessionStore.get(sessionId);
-        if (!session)
-            return;
-        const roomId = resultRoomId ?? roomIdFromSession(session);
-        if (!roomId)
-            return;
-        this.upsertSessionNavigation(session, roomId, undefined, statusFromSession(session) === "unknown"
-            ? "idle"
-            : statusFromSession(session));
-    }
-    readSessions() {
-        const sessions = this.sessionStore.list
-            ? this.sessionStore.list()
-            : this.sessionStore.find({});
-        return sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-    }
-    resolveSession(sessionId) {
-        const session = this.sessionStore.get(sessionId);
-        if (!session) {
-            throw new CliSourceError("session_not_found", `No local Pibo session found for "${sessionId}"`);
-        }
-        return session;
-    }
-    resolveAgent(agentId) {
-        const summary = this.agentSummaries?.find((candidate) => candidate.id === agentId ||
-            candidate.profileName === agentId ||
-            candidate.name === agentId);
-        if (summary)
-            return cloneJson(summary);
-        if (agentId === DEFAULT_PIBO_PROFILE_NAME)
-            return defaultBaseAgentSummary();
-        const agent = this.pluginRegistry
-            .getProfileInfos()
-            .find((candidate) => candidate.name === agentId || candidate.aliases.includes(agentId));
-        if (!agent)
-            throw new CliSourceError("agent_not_found", `No local profile found for "${agentId}"`);
-        return {
-            id: agent.name,
-            name: agent.name,
-            description: agent.description,
-            profileName: agent.name,
-        };
-    }
-    resolveProfile(profile) {
-        try {
-            return resolvePiboProfileNameFromRegistryOrDefault(this.pluginRegistry, profile);
-        }
-        catch (error) {
-            throw toCliSourceError("agent_not_found", `No local profile found for "${profile}"`, error);
-        }
-    }
-    defaultProfileName() {
-        const names = this.pluginRegistry.getProfileNames();
-        return names.includes("base") ? "base" : (names[0] ?? "base");
-    }
-    handleRouterEvent(event) {
-        if (this.closed)
-            return;
-        const session = this.sessionStore.get(event.piboSessionId);
-        if (!session)
-            return;
-        this.ingestOutputEvent(session, event);
-        this.recordOutputEvent(event);
-    }
-    recordOutputEvent(event) {
-        const sessionId = event.piboSessionId;
-        const eventId = "eventId" in event ? event.eventId : undefined;
-        if (event.type === "message_queued" || event.type === "message_started") {
-            this.recordLocalUserMessage(sessionId, eventId ?? randomUUID(), event.text, event.type === "message_started" ? "running" : "done");
-            this.updateSessionStatus(sessionId, "running");
-            return;
-        }
-        if (event.type === "message_finished") {
-            this.updateSessionStatus(sessionId, "idle");
-            return;
-        }
-        if (event.type === "assistant_delta") {
-            this.upsertTraceNode(sessionId, {
-                id: traceNodeId("assistant", eventId, event.assistantIndex ?? event.contentIndex),
-                piboSessionId: sessionId,
-                type: "assistant.message",
-                title: "Agent Message",
-                status: "running",
-                startedAt: this.now(),
-                output: event.text,
-                children: [],
-            }, { appendOutput: true, rawEvent: event });
-            return;
-        }
-        if (event.type === "assistant_message") {
-            this.upsertTraceNode(sessionId, {
-                id: traceNodeId("assistant", eventId, event.assistantIndex ?? event.contentIndex),
-                piboSessionId: sessionId,
-                type: "assistant.message",
-                title: "Agent Message",
-                status: "done",
-                startedAt: this.now(),
-                completedAt: this.now(),
-                output: event.text,
-                children: [],
-            }, { rawEvent: event });
-            return;
-        }
-        if (event.type === "tool_call" ||
-            event.type === "tool_execution_started" ||
-            event.type === "tool_execution_updated" ||
-            event.type === "tool_execution_finished") {
-            const finished = event.type === "tool_execution_finished";
-            this.upsertTraceNode(sessionId, {
-                id: traceNodeId("tool", event.toolCallId),
-                piboSessionId: sessionId,
-                eventId,
-                toolCallId: event.toolCallId,
-                type: finished ? "tool.result" : "tool.call",
-                title: event.toolName,
-                status: finished ? (event.isError ? "error" : "done") : "running",
-                startedAt: this.now(),
-                completedAt: finished ? this.now() : undefined,
-                input: "args" in event ? event.args : undefined,
-                output: finished
-                    ? event.result
-                    : "partialResult" in event
-                        ? event.partialResult
-                        : undefined,
-                children: [],
-            }, { rawEvent: event });
-            return;
-        }
-        if (event.type === "session_error") {
-            this.recordLocalError(sessionId, eventId ?? randomUUID(), event.error);
-            return;
-        }
-        this.appendRawEvent(sessionId, event);
-    }
-    recordLocalUserMessage(sessionId, eventId, text, status) {
-        this.upsertTraceNode(sessionId, {
-            id: traceNodeId("user", eventId),
-            piboSessionId: sessionId,
-            eventId,
-            type: "user.message",
-            title: "User Message",
-            status,
-            startedAt: this.now(),
-            completedAt: status === "done" ? this.now() : undefined,
-            output: text,
-            children: [],
-        }, {
-            rawEvent: {
-                type: "message_queued",
-                piboSessionId: sessionId,
-                eventId,
-                queuedMessages: 0,
-                text,
-                source: "ui",
-            },
-        });
-    }
-    recordLocalError(sessionId, eventId, error) {
-        this.upsertTraceNode(sessionId, {
-            id: traceNodeId("error", eventId),
-            piboSessionId: sessionId,
-            eventId,
-            type: "error",
-            title: "CLI source error",
-            status: "error",
-            startedAt: this.now(),
-            completedAt: this.now(),
-            error: error instanceof Error ? error.message : String(error),
-            children: [],
-        }, {
-            rawEvent: {
-                type: "session_error",
-                piboSessionId: sessionId,
-                eventId,
-                error: error instanceof Error ? error.message : String(error),
-            },
-        });
-        this.updateSessionStatus(sessionId, "error");
-    }
-    upsertTraceNode(sessionId, node, options = {}) {
-        const session = this.resolveSession(sessionId);
-        const traceView = cloneJson(this.traceViews.get(sessionId) ?? emptyTraceView(session));
-        const index = traceView.nodes.findIndex((candidate) => candidate.id === node.id);
-        if (index >= 0) {
-            const previous = traceView.nodes[index];
-            const output = options.appendOutput &&
-                typeof previous.output === "string" &&
-                typeof node.output === "string"
-                ? previous.output + node.output
-                : node.output;
-            traceView.nodes[index] = {
-                ...previous,
-                ...node,
-                output,
-                children: node.children ?? previous.children,
-            };
-        }
-        else {
-            traceView.nodes.push(node);
-        }
-        if (options.rawEvent)
-            traceView.rawEvents.push(storedEvent(options.rawEvent, this.now(), traceView.rawEvents.length + 1));
-        traceView.eventCount = traceView.rawEvents.length;
-        traceView.version = `local-${traceView.rawEvents.length}-${session.updatedAt}`;
-        this.traceViews.set(sessionId, traceView);
-        this.emit(sessionId, {
-            type: "trace",
-            session: sessionToSummary(session, this.ensureDefaultRoom().id),
-            traceView: cloneJson(traceView),
-        });
-    }
-    appendRawEvent(sessionId, event) {
-        const session = this.resolveSession(sessionId);
-        const traceView = cloneJson(this.traceViews.get(sessionId) ?? emptyTraceView(session));
-        traceView.rawEvents.push(storedEvent(event, this.now(), traceView.rawEvents.length + 1));
-        traceView.eventCount = traceView.rawEvents.length;
-        traceView.version = `local-${traceView.rawEvents.length}-${session.updatedAt}`;
-        this.traceViews.set(sessionId, traceView);
-        this.emit(sessionId, {
-            type: "trace",
-            session: sessionToSummary(session, this.ensureDefaultRoom().id),
-            traceView: cloneJson(traceView),
-        });
-    }
-    updateSessionStatus(sessionId, status) {
-        const session = this.resolveSession(sessionId);
-        const updated = this.sessionStore.update(sessionId, {
-            metadata: { ...(session.metadata ?? {}), status },
-        }) ?? session;
-        const summary = sessionToSummary(updated, this.ensureDefaultRoom().id);
-        this.emit(sessionId, {
-            type: "session",
-            session: summary,
-            status: this.buildStatus(updated),
-        });
-    }
-    async loadTraceView(session) {
-        if (!this.dataStore)
-            return cloneJson(this.traceViews.get(session.id) ?? emptyTraceView(session));
-        const rows = this.dataStore.eventLog.listEvents({
-            sessionId: session.id,
-            limit: 500,
-        });
-        const events = rows
-            .map((row) => storedPiboEventFromV2Row(eventLogRowToV2MapperRow(row)))
-            .filter((event) => event !== undefined)
-            .map(normalizeStoredEventForCliTrace);
-        return await buildTraceView({
-            session,
-            sessions: this.readSessions(),
-            events,
-            status: statusFromSession(session) === "running"
-                ? "running"
-                : statusFromSession(session) === "error"
-                    ? "error"
-                    : "idle",
-            cwd: session.workspace ?? getDefaultPiboWorkspace(),
-        });
-    }
-    ingestUserMessage(session, eventId, text) {
-        const roomId = roomIdFromSession(session);
-        if (!this.ingestService || !roomId)
-            return;
-        try {
-            this.ingestService.ingestUserMessageAccepted({
-                session,
-                roomId,
-                actorId: "cli-session-ui",
-                text,
-                clientTxnId: eventId,
-                legacyEvent: { eventId, createdAt: this.now() },
-            });
-        }
-        catch {
-            // Persistence is best-effort; live local rendering still proceeds through router events.
-        }
-    }
-    ingestOutputEvent(session, event) {
-        if (!this.ingestService)
-            return;
-        try {
-            this.ingestService.ingestOutputEvent({
-                session,
-                roomId: roomIdFromSession(session),
-                actorId: session.profile,
-                event,
-                createdAt: this.now(),
-            });
-        }
-        catch {
-            // Persistence is best-effort; live local rendering still proceeds through in-memory trace updates.
-        }
-    }
-    buildStatus(session) {
-        const runtime = this.router?.getSessionRuntimeStatus?.(session.id);
-        return {
-            source: "local/direct",
-            mode: "local",
-            connected: true,
-            rooms: "supported",
-            sessions: "supported",
-            agents: "supported",
-            activeRoomId: roomIdFromSession(session) ?? this.ensureDefaultRoom().id,
-            activeSessionId: session.id,
-            activeAgentId: session.profile,
-            activeModel: session.activeModel,
-            queuedMessages: runtime?.queuedMessages,
-            processing: runtime?.processing,
-            streaming: runtime?.streaming,
-            cwd: runtime?.cwd,
-            thinkingLevel: runtime?.thinkingLevel,
-            fastMode: runtime?.fastMode,
-            contextUsage: runtime?.contextUsage,
-            providerUsage: runtime?.providerUsage,
-            warnings: runtime?.warnings,
-            errors: runtime?.errors,
-            message: redactCliSecretText(runtime
-                ? `Runtime ready; queued=${runtime.queuedMessages} processing=${runtime.processing} streaming=${runtime.streaming}`
-                : (this.statusMessage ?? "Local CLI source ready.")),
-            updatedAt: this.now(),
-        };
-    }
-    async findRoomSummary(roomId) {
-        return (await this.listRooms()).find((room) => room.id === roomId);
-    }
-    ensureDefaultRoom() {
-        if (this.roomService) {
-            const room = this.roomService.ensureDefaultRoom({ name: "Shared Chat" });
-            return {
-                id: room.id,
-                title: room.name,
-                description: room.topic,
-                isDefault: true,
-            };
-        }
-        return defaultCliRoomSummary();
-    }
-    upsertSessionNavigation(session, roomId, lastMessagePreview, status) {
-        if (!this.dataStore)
-            return;
-        const now = this.now();
-        this.dataStore.navigation.upsertSession({
-            roomId,
-            sessionId: session.id,
-            rootSessionId: rootSessionIdFromSession(session),
-            parentId: session.parentId,
-            originId: session.originId,
-            title: session.title || lastMessagePreview || "Untitled Session",
-            profile: session.profile,
-            status,
-            lastActivityAt: now,
-            lastMessagePreview,
-            sortKey: now,
-            updatedAt: now,
-        });
-    }
-    emit(sessionId, update) {
-        const listeners = [...(this.listeners.get(sessionId) ?? [])];
-        for (const listener of listeners)
-            listener(update);
-    }
-    assertOpen() {
-        if (this.closed)
-            throw new CliSourceError("source_closed", "Local CLI session source is closed");
-    }
-}
-export function createLocalCliSessionSource(options = {}) {
-    return new LocalCliSessionSource(options);
-}
-export function redactCliSecretText(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 sessionToSummary(session, defaultRoomId) {
-    return {
-        id: session.id,
-        title: session.title?.trim() || session.id,
-        roomId: roomIdFromSession(session, defaultRoomId),
-        profile: session.profile,
-        agentId: session.profile,
-        workspace: session.workspace,
-        status: statusFromSession(session),
-        model: session.activeModel,
-        createdAt: session.createdAt,
-        updatedAt: session.updatedAt,
-    };
-}
-function deriveRoomsFromSessions(sessions) {
-    const rooms = new Map();
-    for (const session of sessions) {
-        const roomId = roomIdFromSession(session);
-        if (!roomId || rooms.has(roomId))
-            continue;
-        rooms.set(roomId, {
-            id: roomId,
-            title: stringMetadata(session, "chatRoomName") ??
-                stringMetadata(session, "roomName") ??
-                roomId,
-            description: "Derived from local session metadata",
-        });
-    }
-    return [...rooms.values()].sort((left, right) => left.title.localeCompare(right.title));
-}
-function roomIdFromSession(session, defaultRoomId) {
-    return (stringMetadata(session, "chatRoomId") ??
-        stringMetadata(session, "roomId") ??
-        defaultRoomId);
-}
-function statusFromSession(session) {
-    const status = session.metadata?.status;
-    return status === "idle" || status === "running" || status === "error"
-        ? status
-        : "unknown";
-}
-function stringMetadata(session, key) {
-    const value = session.metadata?.[key];
-    return typeof value === "string" && value.trim().length > 0
-        ? value
-        : undefined;
-}
-function buildSessionMetadata(roomId, status, roomName) {
-    if (!roomId)
-        return { status, source: "pibo tui:sessions" };
-    return roomName
-        ? {
-            chatRoomId: roomId,
-            roomId,
-            chatRoomName: roomName,
-            status,
-            source: "pibo tui:sessions",
-        }
-        : { chatRoomId: roomId, roomId, status, source: "pibo tui:sessions" };
-}
-function rootSessionIdFromSession(session) {
-    return session.parentId
-        ? typeof session.metadata?.rootSessionId === "string"
-            ? session.metadata.rootSessionId
-            : session.parentId
-        : session.id;
-}
-function isLegacyCliUnknownSession(session) {
-    return (session.channel === "cli-session-ui" ||
-        session.metadata?.source === "pibo tui:sessions");
-}
-function eventLogRowToV2MapperRow(row) {
-    return {
-        stream_id: row.streamId,
-        session_id: row.sessionId ?? null,
-        session_sequence: row.sessionSequence ?? null,
-        room_id: row.roomId ?? null,
-        type: row.type,
-        actor_type: row.actorType ?? null,
-        actor_id: row.actorId ?? null,
-        event_id: row.eventId ?? null,
-        idempotency_key: row.idempotencyKey ?? null,
-        retention_class: row.retentionClass,
-        preview_text: row.previewText ?? null,
-        attributes_json: JSON.stringify(row.attributes ?? {}),
-        created_at: row.createdAt,
-    };
-}
-function emptyTraceView(session) {
-    return {
-        piboSessionId: session.id,
-        piSessionId: session.piSessionId,
-        title: session.title?.trim() || session.id,
-        version: `local-empty-${session.updatedAt}`,
-        eventCount: 0,
-        nodes: [],
-        rawEvents: [],
-    };
-}
-function normalizeStoredEventForCliTrace(event) {
-    const payload = event.payload;
-    if (payload?.type !== "user.message.accepted")
-        return event;
-    return {
-        ...event,
-        payload: {
-            type: "message_queued",
-            piboSessionId: event.payload
-                .piboSessionId,
-            eventId: payload.clientTxnId,
-            text: payload.text ?? "",
-            source: "ui",
-            queuedMessages: 0,
-        },
-    };
-}
-function storedEvent(event, createdAt, eventSequence) {
-    const eventId = "eventId" in event ? event.eventId : undefined;
-    return {
-        id: eventId ?? `${event.piboSessionId}-${event.type}-${eventSequence}`,
-        piboSessionId: event.piboSessionId,
-        eventSequence,
-        eventId,
-        type: event.type,
-        createdAt,
-        payload: cloneJson(event),
-    };
-}
-function traceNodeId(kind, eventId, index) {
-    return ["local", kind, eventId ?? "event", index]
-        .filter((part) => part !== undefined)
-        .join(":");
-}
-function toCliSourceError(code, message, cause) {
-    return cause instanceof CliSourceError
-        ? cause
-        : new CliSourceError(code, message, { cause });
-}
-function mergeRoomSummaries(rooms) {
-    const byId = new Map();
-    for (const room of rooms) {
-        const existing = byId.get(room.id);
-        byId.set(room.id, existing
-            ? {
-                ...room,
-                ...existing,
-                description: existing.description ?? room.description,
-                isDefault: existing.isDefault === true || room.isDefault === true,
-            }
-            : room);
-    }
-    return [...byId.values()];
-}
-function ensureDefaultRoomSummary(rooms) {
-    const defaultRoom = rooms.find((room) => room.isDefault === true || room.title === "Shared Chat");
-    const normalizedRooms = rooms.map((room) => ({
-        ...room,
-        isDefault: defaultRoom
-            ? room.id === defaultRoom.id || room.isDefault === true
-            : room.isDefault === true,
-    }));
-    if (defaultRoom)
-        return normalizedRooms;
-    return [defaultCliRoomSummary(), ...normalizedRooms];
-}
-function defaultCliRoomSummary() {
-    return {
-        id: cliDefaultRoomId(),
-        title: "Shared Chat",
-        description: "Shared default chat room",
-        isDefault: true,
-    };
-}
-export function cliDefaultRoomId() {
-    return "room_cli_default";
-}
-function normalizeCommandName(command) {
-    return command.trim().replace(/^\/+/, "").toLowerCase();
-}
-function routedActionNameForSlash(command, actionName, args) {
-    if (command === "fork-candidates" && args?.trim())
-        return "session.fork";
-    if (command === "login" && loginAuthMethodFromArgs(args) === "device_code")
-        return "login.start";
-    return actionName;
-}
-function executionParamsForSlash(command, args) {
-    const trimmed = args?.trim();
-    if (command === "compact" && trimmed)
-        return { customInstructions: trimmed };
-    if (command === "thinking" && trimmed)
-        return { level: trimmed };
-    if (command === "model" && trimmed) {
-        const [provider, model] = trimmed.includes("/")
-            ? trimmed.split("/", 2)
-            : [undefined, trimmed];
-        return provider ? { provider, model } : { model };
-    }
-    if (command === "login" && trimmed) {
-        const [provider, method] = parseSlashSelectionArgs(trimmed);
-        if (method === "device_code")
-            return { provider };
-    }
-    if (command === "fork-candidates" && trimmed)
-        return { entryId: trimmed };
-    if (command === "fast" && trimmed)
-        return { mode: trimmed };
-    return undefined;
-}
-function loginAuthMethodFromArgs(args) {
-    const trimmed = args?.trim();
-    if (!trimmed)
-        return undefined;
-    return parseSlashSelectionArgs(trimmed)[1];
-}
-function parseSlashSelectionArgs(value) {
-    const [left, right] = value.includes("/")
-        ? value.split("/", 2)
-        : value.split(/\s+/, 2);
-    return [left ?? "", right];
-}
-function terminalApiKeyLoginInstructions(args) {
-    const [provider] = parseSlashSelectionArgs(args?.trim() ?? "");
-    return {
-        message: `${provider || "Provider"} API-key login requires secret input. The Ink CLI will not echo or collect secrets in this flow; set credentials through provider environment variables or Web Settings, then run /login again.`,
-        supported: true,
-    };
-}
-function terminalDownloadResult(args) {
-    const target = args?.trim();
-    if (!target)
-        return {
-            supported: false,
-            unsupportedReason: "Usage: /download <path>. In a terminal, use shell tools such as cat, cp, scp, or rsync for server paths; browser download APIs are Web-only.",
-        };
-    return {
-        message: `Terminal download for ${target}: this path is already on the server. Use shell tools such as cat, cp, scp, or rsync to copy it; browser download APIs are not used by the CLI.`,
-    };
-}
-function terminalUploadResult(args) {
-    const target = args?.trim();
-    if (!target)
-        return {
-            supported: false,
-            unsupportedReason: "Usage: /upload <path>. Browser file picker upload is Web-only; from SSH, copy files with scp/rsync or place them under ~/.pibo/uploads.",
-        };
-    return {
-        message: `Terminal upload for ${target}: copy or move the file to ~/.pibo/uploads, or use Web /upload for browser file selection. The CLI did not copy file contents or echo secrets.`,
-    };
-}
-function sessionMetadataResult(session, defaultRoomId, roomTitle) {
-    return {
-        piboSessionId: session.id,
-        piSessionId: session.piSessionId,
-        title: session.title,
-        sessionTitle: session.title,
-        profile: session.profile,
-        roomId: roomIdFromSession(session, defaultRoomId),
-        roomTitle,
-        workspace: session.workspace,
-        status: statusFromSession(session),
-        createdAt: session.createdAt,
-        updatedAt: session.updatedAt,
-    };
-}
-function sessionIdFromActionResult(value) {
-    const unwrapped = unwrapActionResult(value);
-    if (!unwrapped || typeof unwrapped !== "object" || Array.isArray(unwrapped))
-        return undefined;
-    const record = unwrapped;
-    return typeof record.piboSessionId === "string"
-        ? record.piboSessionId
-        : typeof record.sessionId === "string"
-            ? record.sessionId
-            : undefined;
-}
-function roomIdFromActionResult(value) {
-    const unwrapped = unwrapActionResult(value);
-    if (!unwrapped || typeof unwrapped !== "object" || Array.isArray(unwrapped))
-        return undefined;
-    const record = unwrapped;
-    return typeof record.roomId === "string" ? record.roomId : undefined;
-}
-function unwrapActionResult(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 defaultBaseAgentSummary() {
-    return {
-        id: DEFAULT_PIBO_PROFILE_NAME,
-        name: DEFAULT_PIBO_PROFILE_NAME,
-        description: "Base agent with only the four Pi built-in tools.",
-        profileName: DEFAULT_PIBO_PROFILE_NAME,
-    };
-}
-function cloneJson(value) {
-    return value === undefined ? value : JSON.parse(JSON.stringify(value));
-}