@vibefield/rosetta-room 0.0.0-stage → 0.1.1

package/dist/HistoryRoom.js

@@ -0,0 +1,440 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The History room, behind the ports a host hands it (`ports.ts`): it opens
+// no socket and no fetch of its own. Columns change content, never geometry
+// (H-2); the ledger's scale is global and stable whatever the filter says. Search is a
+// tool held over the room, not a mode that replaces it (search record,
+// 2026-09-09): the launcher in the strip opens a sheet, a hit lands in the
+// transcript, and the four columns never change what they hold for it. The
+// worktree column is a guest and the measure is not (H-3) — see
+// `components/worktree/use-worktree-guest`, which owns that rule and the
+// engine lifecycle behind it.
+import { forwardRef, useCallback, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState, } from "react";
+import { HostInputsProvider, hostInputsOf, useHostInputs } from "./host-inputs.js";
+import { tildePath } from "./lib/format.js";
+import { MenuLayerProvider } from "./components/HostMenu.js";
+import { RoomProvider, useRoom, useRoomOverlayOpen } from "./room-context.js";
+import { ColdStartPanel } from "./components/ColdStart.js";
+import { ProjectsColumn } from "./components/projects/index.js";
+import { SearchLauncher, SearchSheet, emptyTranscriptPrompt, searchKeyLegend } from "./components/search/index.js";
+import { SessionsColumn } from "./components/sessions/index.js";
+import { TranscriptColumn } from "./components/Transcript.js";
+import { EmptyState } from "./components/ui/index.js";
+import { sessionFilePaths } from "./components/git/index.js";
+import { useWorktreeGuest, WorktreeColumn } from "./components/worktree/index.js";
+import { useDaemonStatus, useMeta, useProjectStats, useProjectUsage, useSearch, useTimeline, } from "./lib/hooks.js";
+import { useIngestActivity } from "./lib/use-ingest-activity.js";
+import { isIngestActive } from "./lib/ingest.js";
+import { UNASSIGNED_PROJECT_ID, buildProjectViewModel, getActivityGridStartTimestamp, projectKey, unassignedProject, } from "./lib/model.js";
+import { compareOrderedSessions } from "./lib/activity-order.js";
+import { useActivityOrder } from "./lib/use-activity-order.js";
+import { createSearchResultsViewModel } from "./lib/search-results.js";
+import { DEFAULT_SEARCH_FILTERS, hitsInReadingOrder, rememberQuery, sessionResultOf, } from "./lib/search-sheet.js";
+import { spendOf } from "./lib/spend.js";
+function useNow(refreshKey) {
+    const [tick, setTick] = useState(() => Date.now());
+    useEffect(() => {
+        const refresh = () => setTick(Date.now());
+        const t = setInterval(refresh, 30_000);
+        window.addEventListener("focus", refresh);
+        document.addEventListener("visibilitychange", refresh);
+        return () => {
+            clearInterval(t);
+            window.removeEventListener("focus", refresh);
+            document.removeEventListener("visibilitychange", refresh);
+        };
+    }, []);
+    // Incoming metadata gets a fresh clock in the same render. Keep it stable
+    // for unrelated UI changes so project aggregates do not recompute per keypress.
+    return useMemo(() => Date.now(), [tick, refreshKey]);
+}
+function insetStyle(inset) {
+    if (inset === undefined)
+        return {};
+    const sides = typeof inset === "number" ? { top: inset, right: inset, bottom: inset, left: inset } : inset;
+    return Object.fromEntries(["top", "right", "bottom", "left"]
+        .filter((side) => sides[side] !== undefined)
+        .map((side) => [`--ah-inset-${side}`, `${sides[side]}px`]));
+}
+/** The element's laid-out width, before the first paint and on every resize;
+ * a transform (the stage receding) does not change it. */
+function useLayoutWidth(ref) {
+    const [width, setWidth] = useState(null);
+    useLayoutEffect(() => {
+        const node = ref.current;
+        if (node === null)
+            return;
+        setWidth(node.clientWidth);
+        const observer = new ResizeObserver((entries) => {
+            const entry = entries[0];
+            if (entry !== undefined)
+                setWidth(entry.contentRect.width);
+        });
+        observer.observe(node);
+        return () => observer.disconnect();
+    }, [ref]);
+    return width;
+}
+/** The room. A host hands it its ports; everything inside reads them from context. */
+export const HistoryRoom = forwardRef(function HistoryRoom(props, ref) {
+    const { catalog, sessions, assets, host } = props;
+    const ports = useMemo(() => ({ catalog, sessions, assets, ...(host === undefined ? {} : { host }) }), [catalog, sessions, assets, host]);
+    return (_jsx(RoomProvider, { ports: ports, options: {
+            initialSummaryTab: props.initialSummaryTab,
+            portalContainer: props.portalContainer,
+            storagePrefix: props.storagePrefix,
+            storage: props.storage,
+        }, children: _jsx(HostInputsProvider, { value: hostInputsOf(props), children: _jsx(RoomBody, { handle: ref, surface: props.surface ?? "paper", search: props.search ?? null, unavailable: props.unavailable ?? null, consent: props.consent ?? null, emptyPrompt: props.emptyPrompt, onSelect: props.onSelect, frameStyle: {
+                    ...insetStyle(props.edgeInset),
+                    ...(props.scrollFoot === undefined ? {} : { "--ah-scroll-foot": props.scrollFoot }),
+                    ...(props.floatingFoot === undefined ? {} : { "--ah-floating-foot": props.floatingFoot }),
+                } }) }) }));
+});
+function RoomBody({ handle, surface, search: searchOption, unavailable, consent, emptyPrompt, onSelect, frameStyle, }) {
+    const { catalog, sessions, host, storage, tints } = useRoom();
+    const { projectTint: hostTint, sessionRow: hostSessionRow, projectActs: hostProjectActs, projectCard: hostProjectCard, sessionActs: hostSessionActs, folders: hostFoldersOf, } = useHostInputs();
+    const overlayOpen = useRoomOverlayOpen();
+    // The room's root, where a host's menus are drawn over every column.
+    const [frameElement, setFrameElement] = useState(null);
+    const { meta, snapshotVersion, status: metaStatus } = useMeta(catalog);
+    const nowMs = useNow(meta);
+    const daemonStatus = useDaemonStatus(catalog);
+    const { connectionError, canonicalReady, searchReadiness: readiness, searchProgress, ingest, } = daemonStatus;
+    const activity = useIngestActivity(daemonStatus);
+    const ingestActive = isIngestActive(ingest);
+    const activityOrder = useActivityOrder(meta, snapshotVersion, metaStatus === "live" && canonicalReady === true && !ingestActive, canonicalReady !== true || ingestActive, nowMs);
+    const [query, setQuery] = useState(() => searchOption?.initialQuery ?? "");
+    // The key the launcher prints and the empty transcript names: only one the
+    // host binds (RO-14).
+    const searchKey = searchKeyLegend(searchOption);
+    const sheetOpen = searchOption?.open ?? false;
+    const setSheetOpen = (open) => searchOption?.onOpenChange(open);
+    const [filters, setFilters] = useState(DEFAULT_SEARCH_FILTERS);
+    const [stepper, setStepper] = useState(null);
+    const [sort, setSort] = useState("recent");
+    const [projectId, setProjectId] = useState(null);
+    const [sessionId, setSessionId] = useState(null);
+    const [inspectedThread, setInspectedThread] = useState(null);
+    const [focus, setFocus] = useState(null);
+    const [receipt, setReceipt] = useState(null);
+    // "This project" is only a scope while there is one; the unassigned
+    // pseudo-project names no project the index could select by.
+    const scopedProjectId = filters.scope === "project" && projectId !== null && projectId !== UNASSIGNED_PROJECT_ID
+        ? projectId
+        : null;
+    const search = useSearch(catalog, query, {
+        project: scopedProjectId,
+        kind: filters.kind === "any" ? null : filters.kind,
+        agent: filters.agent,
+    });
+    const projectIds = useMemo(() => {
+        const ids = (meta?.projects ?? []).map((p) => p.id);
+        if ((meta?.sessions ?? []).some((session) => session.project_id === null)) {
+            ids.push(UNASSIGNED_PROJECT_ID);
+        }
+        return ids.sort();
+    }, [meta]);
+    // Cross-session figures wait for canonical publication. Metadata and
+    // completed timelines remain progressive; aggregate scans never compete
+    // with the sole cold writer for the shared RAM projection.
+    const stats = useProjectStats(catalog, projectIds, canonicalReady === true);
+    const projectRows = useMemo(() => {
+        const rows = [...(meta?.projects ?? [])];
+        if ((meta?.sessions ?? []).some((session) => session.project_id === null)) {
+            rows.push(unassignedProject());
+        }
+        return rows;
+    }, [meta]);
+    const kindOf = useMemo(() => {
+        const byId = new Map((meta?.runtimes ?? []).map((r) => [r.id, r.kind]));
+        return (runtimeId) => byId.get(runtimeId) ?? runtimeId;
+    }, [meta]);
+    const home = useMemo(() => {
+        // The desktop shell knows the home directory outright. The daemon only
+        // knows agent data roots, and it now reports them already shortened
+        // (`~/.claude`) — a string that names no home — so derive from one only
+        // when it is still absolute, and otherwise show paths in full.
+        const fromShell = host?.homeDir ?? null;
+        if (fromShell !== null)
+            return fromShell;
+        const root = meta?.runtimes[0]?.data_root ?? null;
+        if (root === null || !root.startsWith("/"))
+            return null;
+        return root.replace(/\/\.[^/]+$/, "");
+    }, [meta, host]);
+    // R1: the host's colour for a project when it gives one, else the dealt one.
+    const tintOf = useMemo(() => (hostTint === undefined ? tints.projectTint : (id) => hostTint(id) ?? tints.projectTint(id)), [hostTint, tints]);
+    const projectViewModels = useMemo(() => projectRows.map((p) => buildProjectViewModel(p, meta?.sessions ?? [], stats.get(p.id), kindOf, nowMs, tintOf)), [projectRows, meta, stats, kindOf, nowMs, tintOf]);
+    const projectById = useMemo(() => new Map(projectViewModels.map((project) => [project.row.id, project])), [projectViewModels]);
+    // Per-session facts (tokens + messages) from every loaded contribution.
+    const facts = useMemo(() => {
+        const out = new Map();
+        for (const s of stats.values()) {
+            for (const row of s.contribution) {
+                out.set(row.session_id, {
+                    tokens: row.tokens,
+                    messages: row.messages,
+                    spend: spendOf(row),
+                });
+            }
+        }
+        return out;
+    }, [stats]);
+    // Selection is always an explicit reader act. Metadata may invalidate an
+    // existing selection, but arriving data never chooses a project for them.
+    useEffect(() => {
+        if (projectId !== null && !projectById.has(projectId)) {
+            setProjectId(null);
+            setSessionId(null);
+        }
+    }, [projectById, projectId]);
+    const projectSessions = useMemo(() => {
+        if (projectId === null)
+            return [];
+        return (meta?.sessions ?? [])
+            .filter((s) => projectKey(s) === projectId &&
+            s.parent_session_id === null)
+            .sort((left, right) => compareOrderedSessions(left, right, activityOrder));
+    }, [meta, projectId, activityOrder]);
+    useEffect(() => {
+        if (sessionId !== null && !projectSessions.some((s) => s.id === sessionId)) {
+            setSessionId(null);
+        }
+    }, [projectSessions, sessionId]);
+    const viewedSessionId = inspectedThread?.rootId === sessionId ? inspectedThread.id : sessionId;
+    const session = useMemo(() => (meta?.sessions ?? []).find((s) => s.id === viewedSessionId) ?? null, [meta, viewedSessionId]);
+    const openThread = useCallback((id) => {
+        if (sessionId !== null)
+            setInspectedThread({ rootId: sessionId, id });
+    }, [sessionId]);
+    // Attention-directed ingestion: opening a not-yet-indexed session moves
+    // its queued work to the front of the backfill queue. Under slicing the
+    // common case is "streaming" — the starter landed and the completion
+    // remainder is still queued — and that remainder is exactly what the
+    // click promotes; "pending" covers a session no pass has reached at all.
+    // Advisory — a session with nothing queued is a no-op, an old daemon just
+    // keeps its order, and the ledger dedupes repeats.
+    const sessionState = session?.stream_state ?? null;
+    useEffect(() => {
+        if (viewedSessionId === null || sessionState === null || sessionState === "indexed")
+            return;
+        if (ingest?.phase !== "backfilling")
+            return;
+        catalog.boost?.(viewedSessionId).catch(() => { });
+    }, [catalog, viewedSessionId, sessionState, ingest?.phase]);
+    const feed = useTimeline(sessions, viewedSessionId);
+    const usage = useProjectUsage(catalog, projectId, canonicalReady === true);
+    // The selected thread (its root), as a host's acts would continue it.
+    const selected = useMemo(() => (sessionId === null ? null : ((meta?.sessions ?? []).find((s) => s.id === sessionId) ?? null)), [meta, sessionId]);
+    const projectRoot = useMemo(() => {
+        if (projectId === null)
+            return null;
+        const roots = projectById.get(projectId)?.row.root_paths ?? [];
+        if (session?.cwd) {
+            const matching = roots
+                .filter((root) => session.cwd === root || session.cwd?.startsWith(`${root}/`))
+                .sort((a, b) => b.length - a.length)[0];
+            if (matching)
+                return matching;
+        }
+        return roots[0] ?? null;
+    }, [projectId, projectById, session]);
+    /* ── R6: ③'s folder, when the host lists the project's folders ───────
+       The host keys them (two machines spell paths alike). ③ shows the
+       reader's pick while the session stays, else the folder the selected
+       session ran in, else the host's usual place, else the folder at the
+       room's own root; one the host marks elsewhere is never opened here. */
+    const hostFolders = useMemo(() => (projectId === null || hostFoldersOf === undefined ? null : (hostFoldersOf(projectId) ?? null)), [projectId, hostFoldersOf]);
+    const [pickedFolder, setPickedFolder] = useState(null);
+    // A pick lasts while its session does: choosing a session again follows it.
+    useEffect(() => setPickedFolder(null), [projectId, sessionId]);
+    const shownFolder = useMemo(() => {
+        if (hostFolders === null)
+            return null;
+        const all = hostFolders.groups.flatMap((group) => group.folders);
+        const byKey = (key) => key === null || key === undefined ? null : (all.find((folder) => folder.key === key) ?? null);
+        const picked = pickedFolder !== null && pickedFolder.projectId === projectId && pickedFolder.sessionId === sessionId
+            ? byKey(pickedFolder.key)
+            : null;
+        return picked
+            ?? (selected !== null ? byKey(hostFolders.of?.(selected)) : byKey(hostFolders.initial))
+            ?? all.find((folder) => folder.path === projectRoot && folder.elsewhere === undefined)
+            ?? null;
+    }, [hostFolders, pickedFolder, projectId, sessionId, selected, projectRoot]);
+    const shownFolderKey = shownFolder?.key ?? null;
+    // The root ③ reads: the shown folder's, none for one elsewhere, else the room's.
+    const worktreeRoot = shownFolder === null ? projectRoot : shownFolder.elsewhere === undefined ? shownFolder.path : null;
+    const onShowFolder = useRef(hostFolders?.onShow);
+    onShowFolder.current = hostFolders?.onShow;
+    const listsFolders = hostFolders !== null;
+    useEffect(() => {
+        if (listsFolders)
+            onShowFolder.current?.(shownFolderKey);
+    }, [listsFolders, projectId, shownFolderKey]);
+    const folderMenu = useMemo(() => {
+        if (hostFolders === null || projectId === null)
+            return null;
+        return {
+            label: "Folders",
+            filterAfter: hostFolders.filterAfter,
+            filterPlaceholder: hostFolders.filterPlaceholder,
+            groups: hostFolders.groups.map((group) => ({
+                key: group.key,
+                title: group.title,
+                items: group.folders.map((folder) => ({
+                    key: folder.key,
+                    mark: folder.mark,
+                    label: folder.label ?? tildePath(folder.path, home),
+                    detail: folder.detail,
+                    aside: folder.aside,
+                    depth: folder.depth,
+                    checked: folder.key === shownFolderKey,
+                    filterText: folder.path,
+                    onSelect: () => setPickedFolder({ projectId, sessionId, key: folder.key }),
+                    act: folder.act,
+                })),
+            })),
+        };
+    }, [hostFolders, projectId, sessionId, shownFolderKey, home]);
+    // Which files this session touched — the one fact a git client cannot show.
+    // Empty until the typed tool projection ships `file_change` actions, which
+    // draws no marks rather than guessing at them.
+    const sessionPaths = useMemo(() => sessionFilePaths(feed.rows, worktreeRoot), [feed.rows, worktreeRoot]);
+    /* ── column ③, a guest per H-3 ──────────────────────────────────────────
+       Files, changes and history are one column now, so the room is back to
+       one guest and the record's original rule applies unchanged: below a
+       1360px frame it closes rather than squeeze the transcript. */
+    const roomRef = useRef(null);
+    const roomWidth = useLayoutWidth(roomRef);
+    const worktree = useWorktreeGuest(worktreeRoot, roomWidth);
+    // The host hears which session is selected — what its own acts (Resume)
+    // would continue — on mount and whenever it changes.
+    const onSelectRef = useRef(onSelect);
+    onSelectRef.current = onSelect;
+    // R4: the host's key rides out with the selection, never read here.
+    const hostKey = selected === null ? undefined : hostSessionRow?.(selected)?.hostKey;
+    const selectionKey = selected === null
+        ? null
+        : `${selected.id}\u0000${selected.native_session_id}\u0000${selected.cwd ?? ""}${hostKey === undefined ? "" : `\u0000${hostKey}`}`;
+    useEffect(() => {
+        onSelectRef.current?.(selected === null
+            ? null
+            : {
+                sessionId: selected.id,
+                nativeSessionId: selected.native_session_id,
+                folder: selected.cwd,
+                ...(hostKey === undefined ? {} : { hostKey }),
+            });
+        // `selectionKey` is the selection's identity; `selected` is read with it.
+    }, [selectionKey]);
+    /* ── search: one view model, held over the room ─────────────────────── */
+    const searchResults = useMemo(() => {
+        if (search.query === "" || search.response === null || meta === null)
+            return null;
+        return createSearchResultsViewModel(search.response.hits, meta.sessions, projectById);
+    }, [search.query, search.response, meta, projectById]);
+    // Opening a hit is a continuation, not a navigation: the sheet leaves, the
+    // room opens the thread, the transcript lands on the message, and the
+    // stepper remembers the session's other matches.
+    const openHit = (rootSession, hit) => {
+        rememberQuery(storage, query);
+        setSheetOpen(false);
+        setProjectId(projectKey(rootSession));
+        setSessionId(rootSession.id);
+        setInspectedThread(null);
+        setFocus({ sessionId: hit.session_id, timelineId: hit.timeline_id });
+        const result = searchResults === null ? null : sessionResultOf(searchResults, rootSession.id);
+        const hits = result === null ? [hit] : hitsInReadingOrder(result.hits);
+        const at = hits.findIndex((h) => h.timeline_id === hit.timeline_id && h.session_id === hit.session_id);
+        setStepper({ sessionId: rootSession.id, hits, at: Math.max(0, at) });
+    };
+    const stepMatch = useCallback((delta) => {
+        setStepper((current) => {
+            if (current === null || current.hits.length === 0)
+                return current;
+            const at = (current.at + delta + current.hits.length) % current.hits.length;
+            const hit = current.hits[at];
+            setInspectedThread(null);
+            setFocus({ sessionId: hit.session_id, timelineId: hit.timeline_id });
+            return { ...current, at };
+        });
+    }, []);
+    // A host's "open this": the thread the session belongs to, in its project,
+    // landed on the message when one is named. It waits for the index to
+    // deliver the session, and says so when the index does not have it.
+    const [pendingOpen, setPendingOpen] = useState(null);
+    useEffect(() => {
+        if (pendingOpen === null || meta === null)
+            return;
+        const target = meta.sessions.find((s) => s.id === pendingOpen.sessionId) ?? null;
+        if (target === null) {
+            if (metaStatus !== "live")
+                return;
+            setPendingOpen(null);
+            showReceipt("That session is not in this index");
+            return;
+        }
+        const root = target.parent_session_id === null
+            ? target
+            : (meta.sessions.find((s) => s.id === target.root_session_id) ?? target);
+        setPendingOpen(null);
+        setProjectId(projectKey(root));
+        setSessionId(root.id);
+        setInspectedThread(null);
+        setStepper(null);
+        const timelineId = pendingOpen.timelineId ?? null;
+        setFocus(timelineId === null ? null : { sessionId: target.id, timelineId });
+    }, [pendingOpen, meta, metaStatus]);
+    // ⌘G / ⇧⌘G belong to the host's window; it asks the room to walk.
+    const stepping = useRef(false);
+    stepping.current = stepper !== null;
+    useImperativeHandle(handle, () => ({
+        stepMatch(delta) {
+            if (!stepping.current)
+                return false;
+            stepMatch(delta);
+            return true;
+        },
+        openAt(target) {
+            setPendingOpen({ sessionId: target.sessionId, timelineId: target.timelineId ?? null });
+        },
+    }), [stepMatch]);
+    // The stepper belongs to the session it was born in.
+    useEffect(() => {
+        if (stepper !== null && stepper.sessionId !== sessionId)
+            setStepper(null);
+    }, [sessionId, stepper]);
+    const clearSearch = () => {
+        setQuery("");
+        setStepper(null);
+    };
+    const showReceipt = (text) => {
+        setReceipt(text);
+        window.setTimeout(() => setReceipt(null), 2600);
+    };
+    const kinds = useMemo(() => (meta?.runtimes ?? []).map((r) => r.kind), [meta]);
+    const threadCount = useMemo(() => (meta?.sessions ?? []).filter((s) => s.parent_session_id === null).length, [meta]);
+    // The launcher states the scope in a breath; the sheet's foot states it in
+    // full — the strip is always honest and never furniture (Q5, answered).
+    const launcherPlaceholder = meta === null || threadCount === 0
+        ? "Search your whole agentic past"
+        : `Search ${threadCount.toLocaleString("en-US")} sessions across ${kinds.length} ${kinds.length === 1 ? "agent" : "agents"}`;
+    const stepperState = stepper === null || stepper.sessionId !== sessionId
+        ? null
+        : { query: search.query, at: stepper.at, total: stepper.hits.length };
+    const disconnected = meta === null;
+    // The roll call: discovery is on the board and nothing has been read.
+    const awaitingConsent = ingest?.phase === "awaiting_consent";
+    // The first run before its first metadata batch: the daemon answers and
+    // meters move, but there is not yet a canonical project to render. Once
+    // RAM metadata arrives the ordinary room takes over progressively.
+    const coldStarting = projectRows.length === 0 && ingestActive && ingest !== null && !awaitingConsent;
+    return (_jsx("div", { className: "ah-frame is-tall", "data-ah-surface": surface, "data-ah-overlay": overlayOpen ? "" : undefined, style: frameStyle, ref: setFrameElement, children: _jsxs(MenuLayerProvider, { value: frameElement, children: [_jsxs("div", { className: "ah-room", ref: roomRef, children: [searchOption !== null && (_jsxs("div", { className: "ah-searchbar", children: [_jsx(SearchLauncher, { query: search.query, placeholder: launcherPlaceholder, shortcut: searchKey, onOpen: () => setSheetOpen(true), onClear: clearSearch }), searchOption.accessory] })), disconnected && !coldStarting ? (_jsx(EmptyState, { style: { flex: 1 }, title: metaStatus === "closed"
+                                ? "rosettad is not answering"
+                                : "Connecting to rosettad", description: connectionError ?? unavailable, children: _jsx("div", { className: "ah-meter", children: _jsx("i", { style: { width: metaStatus === "connecting" ? "30%" : "8%" } }) }) })) : awaitingConsent ? (consent ?? (_jsx(EmptyState, { style: { flex: 1 }, title: "Waiting for consent", description: "The index has found agents on this machine and reads nothing until it is told which ones to read." }))) : coldStarting ? (_jsx(ColdStartPanel, { activity: activity })) : (_jsxs("div", { className: "ah-cols", "data-rail": worktree.visible ? "on" : "off", children: [_jsx(ProjectsColumn, { projects: projectViewModels, activityOrder: activityOrder, selectedProjectId: projectId, sort: sort, onSortChange: setSort, homeDirectory: home, currentTimestamp: nowMs, ingest: ingest, activity: activity, onProjectSelect: (id) => {
+                                        setProjectId(id);
+                                        setSessionId(null);
+                                        setInspectedThread(null);
+                                    } }), _jsx(SessionsColumn, { project: projectId ? (projectById.get(projectId) ?? null) : null, sessions: projectSessions, factsBySessionId: facts, getRuntimeKind: kindOf, selectedSessionId: sessionId, usage: usage, activityGridStartTimestamp: getActivityGridStartTimestamp(nowMs), currentTimestamp: nowMs, ingest: ingest, isWorktreeVisible: worktree.available && projectRoot !== null ? worktree.visible : null, onToggleWorktree: worktree.toggle, onSessionSelect: (selectedSession) => { setSessionId(selectedSession.id); setInspectedThread(null); }, hostActs: projectId === null ? null : (hostProjectActs?.(projectId, { folder: shownFolderKey }) ?? null), hostCard: projectId === null || hostProjectCard === undefined ? null : hostProjectCard(projectId) }), _jsx(WorktreeColumn, { projectRoot: worktreeRoot, folders: folderMenu === null ? null : { menu: folderMenu, shown: shownFolder }, tint: projectId ? (projectById.get(projectId)?.tint ?? null) : null, homeDirectory: home, sessionPaths: sessionPaths, currentTimestamp: nowMs, onReceipt: showReceipt, requestError: worktree.error, onRetry: worktree.retry }), _jsx(TranscriptColumn, { session: session, duringBackfill: ingestActive, sessions: meta?.sessions ?? [], project: session ? (projectById.get(projectKey(session)) ?? null) : null, feed: feed, focus: focus, onFocusConsumed: () => setFocus(null), onReceipt: showReceipt, emptyPrompt: emptyPrompt === undefined ? emptyTranscriptPrompt(searchKey) : emptyPrompt, stepper: stepperState, onStepMatch: stepMatch, onDismissStepper: () => setStepper(null), getRuntimeKind: kindOf, homeDirectory: home, onOpenThread: openThread, onBackToParent: session?.parent_session_id == null ? null : () => openThread(session.parent_session_id), headActs: session === null ? null : (hostSessionActs?.(session) ?? null) })] }))] }), searchOption !== null && _jsx(SearchSheet, { open: sheetOpen, onClose: () => setSheetOpen(false), query: query, onQuery: setQuery, filters: filters, onFilters: setFilters, feed: search, results: searchResults, readiness: readiness, progress: searchProgress, canonicalReady: canonicalReady, ingestPaused: ingest?.phase === "metadata_ready", agentKinds: kinds, currentProject: projectId !== null && projectId !== UNASSIGNED_PROJECT_ID
+                        ? (projectById.get(projectId) ?? null)
+                        : null, homeDirectory: home, nowMs: nowMs, getRuntimeKind: kindOf, onOpenHit: openHit }), receipt !== null && _jsx("div", { className: "ah-receipt", children: receipt })] }) }));
+}

package/dist/TranscriptReader.d.ts

@@ -0,0 +1,22 @@
+import type { RoomPorts } from "./ports.js";
+import type { KeyValueStore } from "./lib/room-storage.js";
+/** Where the reader opens: a session, one of its messages, and the words
+ * that matched there. */
+export interface ReaderAddress {
+    readonly sessionId: string;
+    /** The line to land on and keep marked; absent, the session's latest. */
+    readonly timelineId?: string | null | undefined;
+    /** The search that found it: its words are marked in the prose. */
+    readonly query?: string | null | undefined;
+}
+export interface TranscriptReaderProps extends RoomPorts {
+    /** Read by value: a new session or line lands again; the same one does not. */
+    readonly at: ReaderAddress;
+    /** As the room's: `paper` paints the room's ground; `host` paints none. */
+    readonly surface?: "paper" | "host" | undefined;
+    /** As the room's: the fold preference and the site icons are kept here. */
+    readonly storagePrefix?: string | undefined;
+    readonly storage?: KeyValueStore | null | undefined;
+}
+/** One session's transcript, read-only, at a line. */
+export declare function TranscriptReader(props: TranscriptReaderProps): import("react").JSX.Element;

package/dist/TranscriptReader.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The reader: one session's transcript, read-only, landed on a line — what a
+// host shows BEFORE it opens the room there (VibeField's Peek). It reads
+// through the same ports as the room and draws the room's own document, with
+// nothing around it: no head band, no acts, no dialogs, no keys. It writes
+// nothing back to any room; a host that wants the session opened opens the
+// room at the same place (`HistoryRoomHandle.openAt`).
+//
+// The landing stays marked rather than fading, because here it is the point:
+// the line, and the words the search matched in it. How the mark looks is the
+// host's (three tokens, `--ah-match`, `--ah-match-weight` and
+// `--ah-match-line`, set on any element around the reader); unset, it is the
+// room's own neutral match.
+import { useCallback, useMemo, useState } from "react";
+import { RoomProvider, useRoom } from "./room-context.js";
+import { TranscriptColumn } from "./components/Transcript.js";
+import { MatchTermsProvider, ReaderModeProvider, matchTermsOf } from "./components/transcript/reader-context.js";
+import { EmptyState } from "./components/ui/index.js";
+import { useMeta, useTimeline } from "./lib/hooks.js";
+/** One session's transcript, read-only, at a line. */
+export function TranscriptReader(props) {
+    const { catalog, sessions, assets, host } = props;
+    const ports = useMemo(() => ({ catalog, sessions, assets, ...(host === undefined ? {} : { host }) }), [catalog, sessions, assets, host]);
+    return (_jsx(RoomProvider, { ports: ports, options: { storagePrefix: props.storagePrefix, storage: props.storage }, children: _jsx(ReaderBody, { at: props.at, surface: props.surface ?? "paper" }) }));
+}
+function focusOf(at) {
+    const timelineId = at.timelineId ?? null;
+    return timelineId === null ? null : { sessionId: at.sessionId, timelineId };
+}
+function ReaderBody({ at, surface }) {
+    const { catalog, sessions, host } = useRoom();
+    const { meta, status } = useMeta(catalog);
+    // The thread the session belongs to, as the room opens it: a delegated
+    // thread is read inside its root, landed where its line is.
+    const target = useMemo(() => meta?.sessions.find((s) => s.id === at.sessionId) ?? null, [meta, at.sessionId]);
+    const root = useMemo(() => {
+        if (target === null || target.parent_session_id === null)
+            return target;
+        return meta?.sessions.find((s) => s.id === target.root_session_id) ?? target;
+    }, [meta, target]);
+    const feed = useTimeline(sessions, root?.id ?? null);
+    // The landing, by value: a new line lands again, a re-render does not.
+    const landingKey = `${at.sessionId}\u0000${at.timelineId ?? ""}`;
+    const [landing, setLanding] = useState(() => ({ key: landingKey, focus: focusOf(at) }));
+    if (landing.key !== landingKey)
+        setLanding({ key: landingKey, focus: focusOf(at) });
+    const focus = landing.key === landingKey ? landing.focus : focusOf(at);
+    const consumed = useCallback(() => setLanding((current) => ({ ...current, focus: null })), []);
+    const terms = useMemo(() => matchTermsOf(at.query), [at.query]);
+    const [receipt, setReceipt] = useState(null);
+    const showReceipt = useCallback((text) => {
+        setReceipt(text);
+        window.setTimeout(() => setReceipt((current) => (current === text ? null : current)), 2600);
+    }, []);
+    const kindOf = useMemo(() => {
+        const byId = new Map((meta?.runtimes ?? []).map((r) => [r.id, r.kind]));
+        return (runtimeId) => byId.get(runtimeId) ?? runtimeId;
+    }, [meta]);
+    // As the room reads it: the desktop's home, else one an index root still names.
+    const home = useMemo(() => {
+        const fromShell = host?.homeDir ?? null;
+        if (fromShell !== null)
+            return fromShell;
+        const dataRoot = meta?.runtimes[0]?.data_root ?? null;
+        if (dataRoot === null || !dataRoot.startsWith("/"))
+            return null;
+        return dataRoot.replace(/\/\.[^/]+$/, "");
+    }, [meta, host]);
+    return (_jsxs("div", { className: "ah-frame ah-reader", "data-ah-surface": surface, children: [root === null ? (_jsx(EmptyState, { style: { flex: 1 }, title: meta === null
+                    ? status === "closed" ? "The index is not answering" : "Opening the session"
+                    : status === "live" ? "That session is not in this index" : "Opening the session", description: meta === null && status === "closed" ? (catalog.unavailable?.() ?? null) : null })) : (_jsx(ReaderModeProvider, { value: true, children: _jsx(MatchTermsProvider, { value: terms, children: _jsx(TranscriptColumn, { session: root, duringBackfill: false, sessions: meta?.sessions ?? [], project: null, feed: feed, focus: focus, onFocusConsumed: consumed, onReceipt: showReceipt, emptyPrompt: null, stepper: null, onStepMatch: () => undefined, onDismissStepper: () => undefined, getRuntimeKind: kindOf, homeDirectory: home, reader: true }) }) })), receipt !== null && _jsx("div", { className: "ah-receipt", children: receipt })] }));
+}

package/dist/components/ColdStart.d.ts

@@ -0,0 +1,4 @@
+import type { IngestActivity } from "../lib/ingest-activity.js";
+export declare function ColdStartPanel({ activity }: {
+    readonly activity: IngestActivity | null;
+}): import("react").JSX.Element;

package/dist/components/ColdStart.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { IngestStatus } from "./IngestStatus.js";
+export function ColdStartPanel({ activity }) {
+    return (_jsxs("div", { className: "ah-empty ah-cold-start", children: [_jsx("strong", { children: "Bringing your history together" }), _jsx("p", { children: "Your projects will appear here as we discover your conversations." }), _jsx(IngestStatus, { activity: activity })] }));
+}

package/dist/components/FilterChips.d.ts

@@ -0,0 +1,4 @@
+import type { RoomFilter } from "../host-inputs.js";
+export declare function FilterChips({ filters }: {
+    readonly filters: readonly RoomFilter[];
+}): import("react").JSX.Element;

package/dist/components/FilterChips.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { HostMenuButton } from "./HostMenu.js";
+export function FilterChips({ filters }) {
+    return (_jsx("span", { className: "ah-chips", children: filters.map((filter) => (_jsx(HostMenuButton, { menu: filter.menu, className: "ah-chipselect ah-chip", label: filter.accessibleLabel, align: "start", data: { "data-filter": filter.key, "data-set": filter.set === true ? "" : undefined }, children: _jsx("span", { className: "ah-chip__label", children: filter.label }) }, filter.key))) }));
+}

package/dist/components/HostAct.d.ts

@@ -0,0 +1,9 @@
+import type { RoomAct } from "../host-inputs.js";
+/** Where an act sits, which decides its face: a session row's quiet act
+ * (a 20px pill under the pointer), ②'s head (the room's 26px icon button;
+ * its one primary on the go fill), or ④'s head (a pill, the stepper's). */
+export type HostActPlace = "row" | "head" | "pill";
+export declare function HostAct({ act, place }: {
+    readonly act: RoomAct;
+    readonly place: HostActPlace;
+}): import("react").JSX.Element;

package/dist/components/HostAct.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { HostMenuButton } from "./HostMenu.js";
+export function HostAct({ act, place }) {
+    const className = place === "head" ? "ah-iconbtn ah-hostact" : "ah-hostact";
+    const primary = place === "head" && act.primary === true ? "" : undefined;
+    // Its rows are drawn over the columns (`HostMenu`), so a row's act may open
+    // them as well as a head's.
+    if (act.menu !== undefined) {
+        return (_jsx(HostMenuButton, { menu: act.menu, className: className, label: act.label, title: act.label, disabled: act.disabled, align: "end", data: { "data-place": place, "data-act": act.key, "data-primary": primary }, children: act.content }));
+    }
+    return (_jsx("button", { type: "button", className: className, "data-place": place, "data-act": act.key, "data-primary": primary, title: act.label, "aria-label": act.label, disabled: act.disabled === true, onClick: (event) => {
+            // The act is the host's; whatever lies under it stays as it was.
+            event.stopPropagation();
+            act.onPress?.();
+        }, children: act.content }));
+}

package/dist/components/HostMenu.d.ts

@@ -0,0 +1,41 @@
+import type { ReactNode } from "react";
+import type { RoomMenu } from "../host-inputs.js";
+export declare const MenuLayerProvider: import("react").Provider<HTMLElement | null>;
+export interface MenuBox {
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+}
+export interface MenuPlacement {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    /** The most height the rows may take on their side. */
+    readonly room: number;
+    readonly side: "below" | "above";
+}
+/**
+ * Where the rows go, in the box's own coordinates: under their control
+ * (or over it, when there is more room there and not enough below), from the
+ * control's start or end edge, and never past the box's edges less a margin.
+ */
+export declare function placeMenu(control: MenuBox, box: MenuBox, menu: {
+    readonly width: number;
+    readonly height: number;
+}, align: "start" | "end"): MenuPlacement;
+export interface HostMenuButtonProps {
+    readonly menu: RoomMenu;
+    /** The control's own class and face; the room's look for its slot. */
+    readonly className: string;
+    readonly label: string;
+    readonly title?: string | undefined;
+    readonly disabled?: boolean | undefined;
+    /** Data attributes the slot marks its control with. */
+    readonly data?: Readonly<Record<`data-${string}`, string | undefined>> | undefined;
+    /** Which edge of the control the rows hang from. */
+    readonly align?: "start" | "end" | undefined;
+    readonly children: ReactNode;
+}
+/** A control that opens the host's rows. */
+export declare function HostMenuButton({ menu, className, label, title, disabled, data, align, children }: HostMenuButtonProps): import("react").JSX.Element;