@pasko70/pibo 1.0.5 → 1.2.0

package/dist/cli-session/localSessionSource.js

@@ -0,0 +1,1144 @@
+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));
+}