dsh-ssh-tui 0.5.9 → 0.6.0

package/lib/session-list.js

@@ -59,10 +59,29 @@ export function formatSessionTime(timestamp) {
     const pad = (value) => String(value).padStart(2, '0');
     return `${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
 }
-/** Whether one durable event is a user-authored message. */
+/**
+ * Whether one durable event is a message put in front of the model.
+ *
+ * Any source counts, not just `kind: 'user'`: cron continuations, goal nudges
+ * and context snapshots are plugin-authored `user/message` events, and a
+ * session carrying one is not a crashed boot. Treating those as "no input"
+ * made a live mid-turn session look blank — and a blank verdict deletes the
+ * session's directory and stops its Host.
+ */
 function isUserMessageEvent(event) {
-    const candidate = event;
-    return candidate.type === 'user/message' && candidate.data?.source?.kind === 'user';
+    return event.type === 'user/message';
+}
+/** A turn that started and never ended: the session is mid-work, never blank. */
+function hasUnfinishedTurn(events) {
+    let open = 0;
+    for (const event of events) {
+        const type = event.type;
+        if (type === 'turn/start')
+            open += 1;
+        else if (type === 'turn/end')
+            open -= 1;
+    }
+    return open > 0;
 }
 /**
  * Whether the session ever produced a model reply. A failed agent request
@@ -79,13 +98,41 @@ function sessionHasReply(events) {
         return false;
     });
 }
+/**
+ * The persisted generated title, else the user's first input (trimmed to one
+ * short line). `undefined` means the log carries no name of its own and the
+ * caller's fallback (usually the id) has to stand in.
+ */
+function labelFromEvents(events) {
+    const titleEvent = [...events].reverse()
+        .find(event => event.type === 'session/title');
+    const title = titleEvent === undefined
+        ? undefined
+        : titleEvent.data?.title;
+    if (title !== undefined && title !== '')
+        return title;
+    const firstUserMessage = events.find(event => isUserMessageEvent(event));
+    if (firstUserMessage === undefined)
+        return undefined;
+    const text = Array.from((firstUserMessage.data?.content ?? [])
+        .map((block) => {
+        const candidate = block;
+        return candidate.type === 'text' && typeof candidate.text === 'string' ? candidate.text : '';
+    })
+        .join(' ')
+        .replace(/\s+/gu, ' ')
+        .trim())
+        .slice(0, 80)
+        .join('');
+    return text === '' ? undefined : text;
+}
 /**
  * A blank session never saw user input nor a model reply — a boot that died
  * before doing anything. Such sessions are deleted (never listed as
  * resumable) so crashed launches stop littering the picker with raw ids.
  */
-function isBlankSession(hasUserInput, hasReply) {
-    return !hasUserInput && !hasReply;
+function isBlankSession(hasUserInput, hasReply, unfinishedTurn = false) {
+    return !hasUserInput && !hasReply && !unfinishedTurn;
 }
 /** Delete one session's on-disk artifacts (log directory), best effort. */
 async function pruneSessionArtifacts(persistence, meta) {
@@ -101,8 +148,10 @@ async function pruneSessionArtifacts(persistence, meta) {
 }
 /** Upper bound on one inspection batch, so the picker never fans out unbounded. */
 const INSPECT_BATCH_SIZE = 30;
+/** Sessions read before the picker's first paint, and per lazy page after it. */
+export const PICKER_PAGE_SIZE = 9;
 function toResumable(item) {
-    const { hasUserInput: _hasUserInput, hasReply: _hasReply, ...rest } = item;
+    const { hasUserInput: _hasUserInput, hasReply: _hasReply, hasUnfinishedTurn: _unfinished, ...rest } = item;
     return rest;
 }
 function indexFromInspected(item, stat) {
@@ -130,105 +179,184 @@ function inspectedFromIndex(entry) {
     };
 }
 /**
- * List resumable top-level sessions, newest first.
- *
- * Subagent-owned sessions and the current session are excluded. Sessions
- * whose event log cannot be inspected are kept (marked `unreadable`) instead
- * of silently disappearing from history; readable sessions with user input
- * sort first. The label is the persisted title, then the user's first input,
- * then the id.
- * @param persistence - the session persistence service.
- * @param currentId - the live session to exclude (empty at launch).
- * @returns every resumable candidate in display order (attachable live
- *   hosts first, then readable logs, then unreadable).
- */
-export async function listResumableSessions(persistence, currentId, listHosts = listAttachableHosts) {
-    const listing = await listResumableSessionsProgressive(persistence, currentId, { listHosts });
-    return listing.complete;
-}
-/**
- * List resumable sessions, painting the recent page first.
+ * One pass over the store: the header sketch, the cached labels, the attachable
+ * hosts, and an inspection cursor that advances page by page.
  *
- * `onUpdate` fires after the priority page (cached + newest logs) and again
- * after each later inspect batch. Unchanged logs reuse `$DSH_HOME/tui-session-index.json`.
+ * The lazy pager, the progressive listing and the full `/resume` list all drive
+ * this, so the hardening lives in exactly one place: a failed or `detached`
+ * read is never treated as a blank session, and a blank one is only pruned
+ * after it was positively read.
  */
-export async function listResumableSessionsProgressive(persistence, currentId, options = {}) {
-    const listHosts = options.listHosts ?? listAttachableHosts;
-    const indexPath = options.indexPath
-        ?? process.env.DSH_TUI_SESSION_INDEX
-        ?? sessionIndexPath();
-    const priorityCount = options.priorityCount ?? PICKER_PRIORITY_COUNT;
-    const headers = await listPersistenceHeaders(persistence);
-    const candidates = headers
-        .filter(meta => meta.id !== currentId
-        && meta.cwd !== undefined
-        && meta.origin !== 'subagent'
-        && (meta.delegationDepth ?? 0) === 0)
-        .sort((a, b) => b.createdAt - a.createdAt);
-    const [index, hosts] = await Promise.all([
-        loadSessionIndex(indexPath),
-        listHosts(),
-    ]);
-    const keepIds = new Set(candidates.map(meta => String(meta.id)));
-    const indexSizeBefore = index.size;
-    pruneSessionIndex(index, keepIds);
-    let indexDirty = index.size !== indexSizeBefore;
-    const sketchFromHeader = (meta) => {
-        const cached = index.get(String(meta.id));
-        const stat = sessionArtifactStat(persistence, meta);
+class ResumableSessionSource {
+    persistence;
+    currentId;
+    candidates;
+    hosts;
+    index;
+    indexPath;
+    cursor = 0;
+    indexDirty = false;
+    inspected = [];
+    blankLiveIds = new Set();
+    extraLive = new Map();
+    constructor(persistence, currentId, candidates, hosts, index, indexPath) {
+        this.persistence = persistence;
+        this.currentId = currentId;
+        this.candidates = candidates;
+        this.hosts = hosts;
+        this.index = index;
+        this.indexPath = indexPath;
+    }
+    static async open(persistence, currentId, options = {}) {
+        const listHosts = options.listHosts ?? listAttachableHosts;
+        const indexPath = options.indexPath
+            ?? process.env.DSH_TUI_SESSION_INDEX
+            ?? sessionIndexPath();
+        const headers = await listPersistenceHeaders(persistence);
+        const candidates = headers
+            .filter(meta => meta.id !== currentId
+            && meta.cwd !== undefined
+            && meta.origin !== 'subagent'
+            && (meta.delegationDepth ?? 0) === 0)
+            .sort((a, b) => b.createdAt - a.createdAt);
+        const [index, hosts] = await Promise.all([
+            loadSessionIndex(indexPath),
+            listHosts(),
+        ]);
+        const keepIds = new Set(candidates.map(meta => String(meta.id)));
+        const indexSizeBefore = index.size;
+        pruneSessionIndex(index, keepIds);
+        const source = new ResumableSessionSource(persistence, currentId, candidates, hosts, index, indexPath);
+        source.indexDirty = index.size !== indexSizeBefore;
+        return source;
+    }
+    /** Header-only view: cached labels where known, the id (marked) for the rest. */
+    sketch() {
+        const sketchFromHeader = (meta) => {
+            const cached = this.index.get(String(meta.id));
+            const stat = sessionArtifactStat(this.persistence, meta);
+            if (stat.size > 0 && indexEntryMatchesStat(cached, stat) && cached !== undefined) {
+                return inspectedFromIndex(cached);
+            }
+            return {
+                id: meta.id,
+                label: cached?.label && cached.label !== '' ? cached.label : meta.id,
+                updatedAt: cached?.updatedAt ?? meta.createdAt,
+                cwd: meta.cwd ?? cached?.cwd ?? '',
+                hasUserInput: cached?.hasUserInput ?? true,
+                hasReply: cached?.hasReply ?? true,
+                // Nothing but the header has been read yet: the label is the id.
+                labelPending: true,
+            };
+        };
+        const sketched = this.candidates.map(meta => toResumable(sketchFromHeader(meta)));
+        const sketchedById = new Map(sketched.map(item => [item.id, item]));
+        for (const host of this.hosts) {
+            if (host.sessionId === this.currentId)
+                continue;
+            const attach = { pid: host.lock.pid, sock: host.sock, state: host.lock.state };
+            const existing = sketchedById.get(host.sessionId);
+            if (existing !== undefined) {
+                existing.attach = attach;
+                continue;
+            }
+            sketched.unshift({
+                id: host.sessionId,
+                label: host.sessionId,
+                updatedAt: Date.parse(host.lock.startedAt) || Date.now(),
+                cwd: '',
+                attach,
+                // A live Host whose header never made it into the candidate list has no
+                // inspectable label yet either.
+                labelPending: true,
+            });
+        }
+        return sketched;
+    }
+    /** Candidates this source has not inspected yet. */
+    get remaining() {
+        return this.candidates.length - this.cursor;
+    }
+    /** Take the next `count` headers, in order. They are consumed by `resolve`. */
+    peek(count) {
+        const batch = this.candidates.slice(this.cursor, this.cursor + Math.max(0, Math.floor(count)));
+        this.cursor += batch.length;
+        return batch;
+    }
+    /**
+     * Inspect candidates until `count` rows were added, or history runs out.
+     * A batch is read concurrently, but the rows keep the candidate order.
+     */
+    async take(count) {
+        let added = 0;
+        while (added < count && this.cursor < this.candidates.length) {
+            const size = Math.min(Math.max(1, count - added), INSPECT_BATCH_SIZE);
+            const batch = this.peek(size);
+            const settled = await Promise.all(batch.map(async (meta) => this.resolve(meta)));
+            for (const item of settled) {
+                if (item === undefined || !this.showable(item))
+                    continue;
+                this.inspected.push(item);
+                added += 1;
+            }
+        }
+    }
+    /**
+     * Whether a resolved row will actually be shown. A session with a reply but
+     * no input of its own is not a picker row; counting it as one made a page
+     * report rows it never painted (and, when nothing else was left, made the
+     * picker believe the history was empty).
+     */
+    showable(item) {
+        return item.hasUserInput || item.unreadable === true;
+    }
+    /** Keep a resolved row in the display list. */
+    add(item) {
+        if (!this.showable(item))
+            return;
+        this.inspected.push(item);
+    }
+    /** Resolve one header into a row. Blank sessions are pruned and skipped. */
+    async resolve(meta) {
+        const stat = sessionArtifactStat(this.persistence, meta);
+        const cached = this.index.get(String(meta.id));
+        // Fingerprint 0/0 means locate/stat failed: never treat that as a hit.
         if (stat.size > 0 && indexEntryMatchesStat(cached, stat) && cached !== undefined) {
             return inspectedFromIndex(cached);
         }
-        return {
-            id: meta.id,
-            label: cached?.label && cached.label !== '' ? cached.label : meta.id,
-            updatedAt: cached?.updatedAt ?? meta.createdAt,
-            cwd: meta.cwd ?? cached?.cwd ?? '',
-            hasUserInput: cached?.hasUserInput ?? true,
-            hasReply: cached?.hasReply ?? true,
-        };
-    };
-    const sketched = candidates.map(meta => toResumable(sketchFromHeader(meta)));
-    const sketchedById = new Map(sketched.map(item => [item.id, item]));
-    for (const host of hosts) {
-        if (host.sessionId === currentId)
-            continue;
-        const attach = { pid: host.lock.pid, sock: host.sock, state: host.lock.state };
-        const existing = sketchedById.get(host.sessionId);
-        if (existing !== undefined) {
-            existing.attach = attach;
-            continue;
+        const item = await this.inspectCandidate(meta);
+        if (item.unreadable !== true
+            && isBlankSession(item.hasUserInput, item.hasReply, item.hasUnfinishedTurn === true)) {
+            this.index.delete(String(meta.id));
+            this.indexDirty = true;
+            void pruneSessionArtifacts(this.persistence, meta);
+            return undefined;
+        }
+        if (stat.size > 0) {
+            this.index.set(String(meta.id), indexFromInspected(item, stat));
+            this.indexDirty = true;
         }
-        sketched.unshift({
-            id: host.sessionId,
-            label: host.sessionId,
-            updatedAt: Date.parse(host.lock.startedAt) || Date.now(),
-            cwd: '',
-            attach,
-        });
+        return item;
     }
-    options.onUpdate?.({ sessions: sketched, pending: true });
-    const inspectCandidate = async (meta) => {
+    async inspectCandidate(meta) {
         try {
-            const inspection = await inspectPersistenceSession(persistence, meta.id);
-            const firstUserMessage = inspection.events.find(event => isUserMessageEvent(event));
-            const firstUserText = firstUserMessage === undefined
-                ? undefined
-                : Array.from((firstUserMessage.data?.content ?? [])
-                    .map((block) => {
-                    const candidate = block;
-                    return candidate.type === 'text' && typeof candidate.text === 'string' ? candidate.text : '';
-                })
-                    .join(' ')
-                    .replace(/\s+/gu, ' ')
-                    .trim())
-                    .slice(0, 80)
-                    .join('');
-            const titleEvent = [...inspection.events].reverse()
-                .find(event => event.type === 'session/title');
-            const title = titleEvent === undefined
-                ? undefined
-                : titleEvent.data.title;
+            const inspection = await inspectPersistenceSession(this.persistence, meta.id);
+            // A `detached` slice (the writer is in this process and has not
+            // materialized the artifact yet) or an empty one is an unreadable log,
+            // never a blank session. Calling it blank made a listing delete a live
+            // session's directory; keep it visible and let resume report the truth.
+            if (inspection.eventState === 'detached' || inspection.events.length === 0) {
+                const cached = this.index.get(String(meta.id));
+                return {
+                    id: meta.id,
+                    label: cached?.label && cached.label !== '' ? cached.label : meta.id,
+                    updatedAt: cached?.updatedAt ?? meta.createdAt,
+                    cwd: meta.cwd ?? cached?.cwd ?? '',
+                    hasUserInput: cached?.hasUserInput ?? false,
+                    hasReply: cached?.hasReply ?? false,
+                    unreadable: true,
+                };
+            }
             const last = inspection.events.at(-1);
             const updatedAt = last?.time ?? meta.createdAt;
             return {
@@ -237,15 +365,12 @@ export async function listResumableSessionsProgressive(persistence, currentId, o
                 // same `session/title` value, so both surfaces name a session alike
                 // and switching between them stays findable. First user input is the
                 // fallback for sessions whose title has not been generated yet.
-                label: title !== undefined && title !== ''
-                    ? title
-                    : firstUserText !== undefined && firstUserText !== ''
-                        ? firstUserText
-                        : meta.id,
+                label: labelFromEvents(inspection.events) ?? meta.id,
                 updatedAt,
                 cwd: meta.cwd ?? '',
-                hasUserInput: firstUserMessage !== undefined,
+                hasUserInput: inspection.events.some(event => isUserMessageEvent(event)),
                 hasReply: sessionHasReply(inspection.events),
+                ...(hasUnfinishedTurn(inspection.events) ? { hasUnfinishedTurn: true } : {}),
             };
         }
         catch {
@@ -262,38 +387,20 @@ export async function listResumableSessionsProgressive(persistence, currentId, o
                 unreadable: true,
             };
         }
-    };
-    const resolveCandidate = async (meta) => {
-        const stat = sessionArtifactStat(persistence, meta);
-        const cached = index.get(String(meta.id));
-        // Fingerprint 0/0 means locate/stat failed: never treat that as a hit.
-        if (stat.size > 0 && indexEntryMatchesStat(cached, stat) && cached !== undefined) {
-            return inspectedFromIndex(cached);
-        }
-        const item = await inspectCandidate(meta);
-        if (item.unreadable !== true && isBlankSession(item.hasUserInput, item.hasReply)) {
-            index.delete(String(meta.id));
-            indexDirty = true;
-            void pruneSessionArtifacts(persistence, meta);
-            return undefined;
-        }
-        if (stat.size > 0) {
-            index.set(String(meta.id), indexFromInspected(item, stat));
-            indexDirty = true;
-        }
-        return item;
-    };
-    const inspected = [];
-    const blankLiveIds = new Set();
-    const extraLive = new Map();
-    const mergeHosts = async (items) => {
-        const resumable = items.filter(item => item.hasUserInput || item.unreadable === true);
+    }
+    /**
+     * The display list: the rows read so far with the attachable hosts merged in.
+     * Attachable hosts come first, then readable logs newest-first, then the
+     * unreadable ones (they may still be resumable, so they stay selectable).
+     */
+    async listing() {
+        const resumable = this.inspected.filter(item => this.showable(item));
         const byId = new Map(resumable.map(item => [item.id, item]));
-        for (const host of hosts) {
-            if (host.sessionId === currentId || blankLiveIds.has(host.sessionId))
+        for (const host of this.hosts) {
+            if (host.sessionId === this.currentId || this.blankLiveIds.has(host.sessionId))
                 continue;
             const attach = { pid: host.lock.pid, sock: host.sock, state: host.lock.state };
-            const existing = byId.get(host.sessionId) ?? extraLive.get(host.sessionId);
+            const existing = byId.get(host.sessionId) ?? this.extraLive.get(host.sessionId);
             if (existing !== undefined) {
                 existing.attach = attach;
                 if (!byId.has(host.sessionId)) {
@@ -304,73 +411,171 @@ export async function listResumableSessionsProgressive(persistence, currentId, o
             }
             // A live Host whose session never saw input nor a reply is a crashed
             // boot: stop it, remove its artifacts, and keep it out of the picker.
+            // Only a positively read, materialized blank log counts. A failed or
+            // detached read is unknown — acting on it (SIGTERM + prune) removed a
+            // live session's directory before.
             let blankLive = false;
-            let liveHasUserInput = true;
+            let unreadableLive = false;
+            let liveHasUserInput = false;
+            let liveLabel;
             try {
-                const inspection = await inspectPersistenceSession(persistence, host.sessionId);
-                const hasInput = inspection.events.some(event => isUserMessageEvent(event));
-                blankLive = isBlankSession(hasInput, sessionHasReply(inspection.events));
-                liveHasUserInput = hasInput;
+                const inspection = await inspectPersistenceSession(this.persistence, host.sessionId);
+                const materialized = inspection.eventState !== 'detached' && inspection.events.length > 0;
+                if (!materialized) {
+                    unreadableLive = true;
+                }
+                else {
+                    const hasInput = inspection.events.some(event => isUserMessageEvent(event));
+                    blankLive = isBlankSession(hasInput, sessionHasReply(inspection.events), hasUnfinishedTurn(inspection.events));
+                    liveHasUserInput = hasInput;
+                    // A Host that is running but absent from the header list still has a
+                    // log; read its title rather than offering the user a raw uuid.
+                    liveLabel = labelFromEvents(inspection.events);
+                }
             }
             catch {
-                blankLive = true;
-                liveHasUserInput = false;
+                // A read failure is not evidence of a blank boot either: keep the live
+                // Host attachable instead of killing it and pruning its log.
+                unreadableLive = true;
             }
             if (blankLive) {
-                blankLiveIds.add(host.sessionId);
+                this.blankLiveIds.add(host.sessionId);
                 try {
                     process.kill(attach.pid, 'SIGTERM');
                 }
                 catch { /* already gone */ }
-                const header = candidates.find(candidate => candidate.id === host.sessionId);
+                const header = this.candidates.find(candidate => candidate.id === host.sessionId);
                 if (header !== undefined)
-                    void pruneSessionArtifacts(persistence, header);
+                    void pruneSessionArtifacts(this.persistence, header);
                 continue;
             }
             const injected = {
                 id: host.sessionId,
-                label: host.sessionId,
+                // No readable log means no title: say so instead of showing a uuid the
+                // user cannot recognise (and let the tail of the id still be searched).
+                label: liveLabel ?? (unreadableLive ? t('picker.noLogLabel', { short: host.sessionId.slice(-8) }) : host.sessionId),
                 updatedAt: Date.parse(host.lock.startedAt) || Date.now(),
                 cwd: '',
-                hasUserInput: liveHasUserInput,
+                hasUserInput: liveHasUserInput || unreadableLive,
                 hasReply: true,
+                ...(unreadableLive ? { unreadable: true } : {}),
                 attach,
             };
-            extraLive.set(host.sessionId, injected);
+            this.extraLive.set(host.sessionId, injected);
             resumable.push(injected);
             byId.set(host.sessionId, injected);
         }
         resumable.sort((a, b) => (a.attach === undefined ? 1 : 0) - (b.attach === undefined ? 1 : 0)
             || (a.unreadable === true ? 1 : 0) - (b.unreadable === true ? 1 : 0)
             || b.updatedAt - a.updatedAt);
-        return resumable;
-    };
-    const emit = async (pending) => {
-        const listed = (await mergeHosts(inspected)).map(toResumable);
-        options.onUpdate?.({ sessions: listed, pending });
+        return resumable.map(toResumable);
+    }
+    async emit(pending, onUpdate) {
+        const listed = await this.listing();
+        onUpdate?.({ sessions: listed, pending });
         return listed;
+    }
+    /**
+     * Persist the labels read so far. Flushed after every page: a picker the user
+     * closed (or a `/resume` that ran while the Host booted) must not leave the
+     * next listing without titles again.
+     */
+    async flushIndex() {
+        if (!this.indexDirty)
+            return;
+        await saveSessionIndex(this.indexPath, this.index);
+        this.indexDirty = false;
+    }
+}
+/**
+ * Open a pager over the store. Nothing is inspected until the first `page()`.
+ */
+export async function openResumableSessionPager(persistence, currentId, options = {}) {
+    const source = await ResumableSessionSource.open(persistence, currentId, options);
+    return {
+        page: async (size = PICKER_PAGE_SIZE) => {
+            // `take` counts only showable rows, so a page that comes back with no
+            // rows is a page the history is exhausted by — never a page whose rows
+            // were filtered out after being counted.
+            const wanted = Number.isFinite(size) && size > 0 ? Math.floor(size) : PICKER_PAGE_SIZE;
+            await source.take(wanted);
+            await source.flushIndex();
+            return {
+                sessions: await source.listing(),
+                remaining: source.remaining,
+                done: source.remaining === 0,
+            };
+        },
+        complete: async () => {
+            await source.take(Number.POSITIVE_INFINITY);
+            const sessions = await source.listing();
+            await source.flushIndex();
+            return sessions;
+        },
     };
-    // Newest page first so the picker can paint before older logs are parsed.
-    const priority = candidates.slice(0, Math.max(0, priorityCount));
-    const rest = candidates.slice(priority.length);
-    const first = await Promise.all(priority.map(async (meta) => ({ meta, item: await resolveCandidate(meta) })));
-    for (const { item } of first) {
-        if (item !== undefined)
-            inspected.push(item);
+}
+/**
+ * List resumable top-level sessions, newest first.
+ *
+ * Subagent-owned sessions and the current session are excluded. Sessions
+ * whose event log cannot be inspected are kept (marked `unreadable`) instead
+ * of silently disappearing from history; readable sessions with user input
+ * sort first. The label is the persisted title, then the user's first input,
+ * then the id.
+ * @param persistence - the session persistence service.
+ * @param currentId - the live session to exclude (empty at launch).
+ * @returns every resumable candidate in display order (attachable live
+ *   hosts first, then readable logs, then unreadable).
+ */
+export async function listResumableSessions(persistence, currentId, listHosts = listAttachableHosts) {
+    const pager = await openResumableSessionPager(persistence, currentId, { listHosts });
+    return pager.complete();
+}
+/**
+ * List resumable sessions, painting the recent page first.
+ *
+ * `onUpdate` fires after the header sketch, after the first resolved title, and
+ * again after each later inspect batch. Unchanged logs reuse
+ * `$DSH_HOME/tui-session-index.json`.
+ */
+export async function listResumableSessionsProgressive(persistence, currentId, options = {}) {
+    const source = await ResumableSessionSource.open(persistence, currentId, options);
+    options.onUpdate?.({ sessions: source.sketch(), pending: true });
+    const priorityCount = options.priorityCount ?? PICKER_PRIORITY_COUNT;
+    const priority = source.peek(priorityCount);
+    // Paint the first real title as soon as it exists instead of waiting for the
+    // whole newest page. With a cold index that is the difference between a
+    // loading line and a list the user can already pick from.
+    let firstPainted = false;
+    const first = await Promise.all(priority.map(async (meta) => {
+        const item = await source.resolve(meta);
+        // Only a caller that paints progressively gets the early frame.
+        if (!firstPainted && item !== undefined && source.remaining > 0 && options.onUpdate !== undefined) {
+            firstPainted = true;
+            source.add(item);
+            await source.flushIndex();
+            await source.emit(true, options.onUpdate);
+            return { item, painted: true };
+        }
+        return { item, painted: false };
+    }));
+    for (const { item, painted } of first) {
+        if (item !== undefined && !painted)
+            source.add(item);
     }
-    await emit(rest.length > 0);
-    for (let offset = 0; offset < rest.length; offset += INSPECT_BATCH_SIZE) {
-        const batch = rest.slice(offset, offset + INSPECT_BATCH_SIZE);
-        const settled = await Promise.all(batch.map(async (meta) => ({ meta, item: await resolveCandidate(meta) })));
-        for (const { item } of settled) {
+    await source.flushIndex();
+    await source.emit(source.remaining > 0, options.onUpdate);
+    while (source.remaining > 0) {
+        const batch = source.peek(INSPECT_BATCH_SIZE);
+        const settled = await Promise.all(batch.map(async (meta) => source.resolve(meta)));
+        for (const item of settled) {
             if (item !== undefined)
-                inspected.push(item);
+                source.add(item);
         }
-        await emit(offset + INSPECT_BATCH_SIZE < rest.length);
+        await source.emit(source.remaining > 0, options.onUpdate);
     }
-    const complete = (await mergeHosts(inspected)).map(toResumable);
-    if (indexDirty)
-        await saveSessionIndex(indexPath, index);
+    const complete = await source.listing();
+    await source.flushIndex();
     options.onUpdate?.({ sessions: complete, pending: false });
     return { sessions: complete, pending: false, complete };
 }