@deepseek-harness-tui/dsh-tui 0.7.1 → 0.7.2

package/lib/types/dsh-adapter/sessions/header.js

@@ -0,0 +1,62 @@
+/** A finite number, or undefined for anything else (NaN and ±Infinity included). */
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+/** A non-empty string, or undefined. */
+function text(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/**
+ * Narrow one listed header.
+ *
+ * @param value - A header as the persistence service returned it.
+ * @returns The fields this feature uses, or undefined when the value carries
+ *   no usable session id — the one field nothing can substitute for.
+ */
+export function readHeader(value) {
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    const id = text(record['id']);
+    if (id === undefined)
+        return undefined;
+    return {
+        id,
+        cwd: text(record['cwd']),
+        createdAt: finiteNumber(record['createdAt']),
+        parentSession: text(record['parentSession']),
+        origin: text(record['origin']),
+        delegationDepth: finiteNumber(record['delegationDepth']),
+        seedLength: finiteNumber(record['seedLength']),
+        agentPreset: text(record['agentPreset']),
+    };
+}
+/**
+ * Decide what a session is, from its header alone.
+ *
+ * Precedence is `origin` first, lineage second, and that order is the whole
+ * correctness argument: a `/rewind` fork records `parentSession` exactly like
+ * a delegated run does, and only `origin` separates them. Upstream documents
+ * `origin` as "coarse product classification for a session created as a
+ * subagent child … presentation metadata", which is precisely this decision.
+ *
+ * `delegationDepth` is optional upstream, so a sub-agent whose header omits it
+ * is reported at depth 1: it is a delegated child by `origin`, and 1 is the
+ * shallowest depth that can be.
+ *
+ * @param header - A narrowed header.
+ * @returns The session's kind.
+ */
+export function classify(header) {
+    if (header.origin === 'subagent') {
+        return {
+            kind: 'subagent',
+            parent: header.parentSession,
+            depth: header.delegationDepth ?? 1,
+        };
+    }
+    if (header.parentSession !== undefined) {
+        return { kind: 'fork', parent: header.parentSession };
+    }
+    return { kind: 'root' };
+}

package/lib/types/dsh-adapter/sessions/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Persisted-session metadata — the adapter-side barrel.
+ *
+ * This directory is the only part of the session browser allowed to know how
+ * sessions are stored: the persistence service's shape, the log's frame
+ * container, the header's lineage fields. The browser screen and its
+ * components are pure UI over the types re-exported here and never touch a
+ * session log directly, which is what `verify-adapter-boundary` enforces.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/sessions
+ */
+export { classify, readHeader, type RawSessionHeader } from './header.js';
+export { digestSession, previewSession } from './digest.js';
+export { listSummaries, locateSession, type SessionSource } from './list.js';
+export { noteBranch, readIndex, writeIndex, type IndexEntry, type SessionIndex } from './store.js';
+export type { PreviewEntry, SessionDigest, SessionKind, SessionSummary, SessionTitle, TitleSource, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/dsh-adapter/sessions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/sessions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEzE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAE3D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,WAAW,CAAA;AAE5E,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAA;AAElG,YAAY,EACV,YAAY,EACZ,aAAa,EACb,WAAW,EACX,cAAc,EACd,YAAY,EACZ,WAAW,GACZ,MAAM,YAAY,CAAA"}

package/lib/types/dsh-adapter/sessions/index.js

@@ -0,0 +1,15 @@
+/**
+ * Persisted-session metadata — the adapter-side barrel.
+ *
+ * This directory is the only part of the session browser allowed to know how
+ * sessions are stored: the persistence service's shape, the log's frame
+ * container, the header's lineage fields. The browser screen and its
+ * components are pure UI over the types re-exported here and never touch a
+ * session log directly, which is what `verify-adapter-boundary` enforces.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/sessions
+ */
+export { classify, readHeader } from './header.js';
+export { digestSession, previewSession } from './digest.js';
+export { listSummaries, locateSession } from './list.js';
+export { noteBranch, readIndex, writeIndex } from './store.js';

package/lib/types/dsh-adapter/sessions/list.d.ts

@@ -0,0 +1,41 @@
+import type { SessionSummary } from './types.js';
+/**
+ * The slice of `ctx.sessionPersistence` this module uses.
+ *
+ * Structural and fully optional: the service is resolved from a running
+ * context whose packages may be a version apart from ours, and a listing that
+ * degrades is worth more than one that throws.
+ */
+export interface SessionSource {
+    /** Headers plus per-log change tokens — the contract built for this. */
+    listSnapshots?: (signal?: AbortSignal) => Promise<readonly unknown[]>;
+    /** Headers alone, for a backend or version without snapshots. */
+    list?: (signal?: AbortSignal) => Promise<readonly unknown[]>;
+    /** Absolute artifact path for one header; absent for storeless backends. */
+    locate?: (meta: unknown) => unknown;
+}
+/**
+ * Read every stored session into a complete summary.
+ *
+ * @param source - The persistence service.
+ * @param signal - Optional cancellation for the backend's own listing work.
+ * @returns One summary per stored session, most recently active first. No
+ *   filtering of any kind is applied — sub-agent runs and sessions with no
+ *   conversation are present and labelled as such.
+ */
+export declare function listSummaries(source: SessionSource, signal?: AbortSignal): Promise<readonly SessionSummary[]>;
+/**
+ * Resolve one session's artifact path.
+ *
+ * Listing headers is a first-line-only read per log — about 2 ms across a
+ * fifty-session history — so the preview pane resolves its target this way
+ * rather than making every summary carry a filesystem path it has no business
+ * knowing about.
+ *
+ * @param source - The persistence service.
+ * @param sessionId - Session to locate.
+ * @returns The absolute artifact path, or undefined when the backend owns no
+ *   per-session file or the session is gone.
+ */
+export declare function locateSession(source: SessionSource, sessionId: string, signal?: AbortSignal): Promise<string | undefined>;
+//# sourceMappingURL=list.d.ts.map

package/lib/types/dsh-adapter/sessions/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/sessions/list.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGhD;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,SAAS,OAAO,EAAE,CAAC,CAAA;IACrE,iEAAiE;IACjE,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,SAAS,OAAO,EAAE,CAAC,CAAA;IAC5D,4EAA4E;IAC5E,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAA;CACpC;AA0ED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,aAAa,EACrB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,SAAS,cAAc,EAAE,CAAC,CA8FpC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAS7B"}

package/lib/types/dsh-adapter/sessions/list.js

@@ -0,0 +1,213 @@
+/**
+ * Building the session list.
+ *
+ * One resolution path produces one complete, honestly-classified record per
+ * stored session — every kind, empties included — and callers decide what to
+ * show. That split is deliberate: the old picker filtered while it resolved,
+ * so "hide sub-agent runs" and "resolve a title" were the same pass and
+ * neither could change without disturbing the other. Here the browser can
+ * toggle sub-agent runs into view, or offer to clean up boot artifacts,
+ * without re-deriving anything.
+ *
+ * Cost: one `stat` per session always, plus one bounded log read per session
+ * whose revision moved since the last listing. On a warm index that is zero
+ * log reads. The path this replaces decompressed every frame of the twenty
+ * most recent logs on every open — 3.9 s over a 31 MB history.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/sessions/list
+ */
+import { basename } from 'node:path';
+import { digestSession } from './digest.js';
+import { fileFacts } from './frames.js';
+import { classify, readHeader } from './header.js';
+import { findSessionLogFile } from '../compat/sessionLog.js';
+import { readIndex, writeIndex } from './store.js';
+import { readLastUsed } from '../../sessionHistory.js';
+/** Pull `{ header, revision }` out of one `listSnapshots()` element. */
+function readSnapshot(value) {
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    const raw = record['header'];
+    const header = readHeader(raw);
+    if (header === undefined)
+        return undefined;
+    const revision = record['revision'];
+    return { header, raw, revision: typeof revision === 'string' ? revision : undefined };
+}
+/**
+ * Enumerate stored sessions.
+ *
+ * Prefers `listSnapshots()` because its revision is the backend's own answer
+ * to "has this log changed", and falls back to `list()` when the resolved
+ * service predates it — in which case the change token is derived from the
+ * file's own size and mtime further down. Both are honest change tokens for an
+ * append-only log; only the authority differs.
+ */
+async function enumerate(source, signal) {
+    if (typeof source.listSnapshots === 'function') {
+        const snapshots = await source.listSnapshots(signal);
+        return snapshots.map(readSnapshot).filter((entry) => entry !== undefined);
+    }
+    if (typeof source.list === 'function') {
+        const headers = await source.list(signal);
+        return headers
+            .map((raw) => {
+            const header = readHeader(raw);
+            return header === undefined ? undefined : { header, raw, revision: undefined };
+        })
+            .filter((entry) => entry !== undefined);
+    }
+    return [];
+}
+/**
+ * Absolute artifact path for one session.
+ *
+ * The backend's own `locate()` is authoritative and is asked first. The
+ * fallback scans the session roots for the id, which is what the compat layer
+ * has always done and is deliberately independent of the backend's
+ * workspace-key scheme — so a runtime whose persistence service predates
+ * `locate`, or whose key sanitization changes, still resolves.
+ *
+ * A backend that stores no per-session artifact (SQLite) answers neither, and
+ * its sessions are summarized from their headers alone.
+ */
+function locate(source, raw, sessionId) {
+    if (typeof source.locate === 'function') {
+        let location;
+        try {
+            location = source.locate(raw);
+        }
+        catch {
+            location = undefined;
+        }
+        if (location !== null && typeof location === 'object') {
+            const path = location['path'];
+            if (typeof path === 'string' && path.length > 0)
+                return path;
+        }
+    }
+    return findSessionLogFile(sessionId);
+}
+/**
+ * Read every stored session into a complete summary.
+ *
+ * @param source - The persistence service.
+ * @param signal - Optional cancellation for the backend's own listing work.
+ * @returns One summary per stored session, most recently active first. No
+ *   filtering of any kind is applied — sub-agent runs and sessions with no
+ *   conversation are present and labelled as such.
+ */
+export async function listSummaries(source, signal) {
+    let listed;
+    try {
+        listed = await enumerate(source, signal);
+    }
+    catch {
+        return [];
+    }
+    // Children are counted from the same listing rather than by walking logs:
+    // lineage lives in the header, so a parent's sub-agent count is free.
+    const children = new Map();
+    for (const entry of listed) {
+        if (entry.header.origin !== 'subagent')
+            continue;
+        const parent = entry.header.parentSession;
+        if (parent === undefined)
+            continue;
+        children.set(parent, (children.get(parent) ?? 0) + 1);
+    }
+    const index = readIndex();
+    const next = new Map();
+    const lastUsed = readLastUsed();
+    let changed = false;
+    const summaries = [];
+    for (const { header, raw, revision } of listed) {
+        const cached = index.get(header.id);
+        const path = locate(source, raw, header.id);
+        const facts = path === undefined ? undefined : fileFacts(path);
+        // Falls back to the file's own identity when the backend offered no token.
+        const token = revision ?? (facts === undefined ? undefined : `${facts.bytes}:${facts.modifiedAt}`);
+        let derived;
+        if (cached?.derived !== undefined && token !== undefined && cached.derived.revision === token) {
+            derived = cached.derived;
+        }
+        else if (path !== undefined && token !== undefined) {
+            const digest = digestSession(path, header.cwd ?? '');
+            derived = {
+                revision: token,
+                title: digest.title?.text ?? '',
+                titleSource: digest.title?.source ?? 'fallback',
+                hasPrompt: digest.hasPrompt,
+                model: digest.model,
+                label: digest.label,
+            };
+            changed = true;
+        }
+        // Carry every entry that holds anything worth keeping — including a pure
+        // cache hit, which must survive into the next index or the following
+        // listing would re-derive everything it just reused.
+        if (derived !== undefined || cached?.branch !== undefined) {
+            next.set(header.id, { derived, branch: cached?.branch });
+        }
+        const createdAt = header.createdAt ?? facts?.modifiedAt ?? 0;
+        summaries.push({
+            id: header.id,
+            kind: classify(header),
+            title: {
+                text: derived?.title !== undefined && derived.title.length > 0
+                    ? derived.title
+                    : basename(header.cwd ?? '') || header.id.slice(0, 8),
+                source: derived?.titleSource ?? 'fallback',
+            },
+            cwd: header.cwd ?? '',
+            createdAt,
+            updatedAt: Math.max(facts?.modifiedAt ?? 0, lastUsed[header.id] ?? 0, createdAt),
+            bytes: facts?.bytes,
+            // Without a readable artifact nothing can be proven empty, and hiding a
+            // real session is the worse error — so an unreadable log is listed.
+            hasPrompt: derived?.hasPrompt ?? true,
+            agentPreset: header.agentPreset,
+            model: derived?.model,
+            label: derived?.label,
+            branch: cached?.branch,
+            childCount: children.get(header.id) ?? 0,
+        });
+    }
+    // Entries for sessions the backend no longer lists are dropped here; that is
+    // the whole of the cache's garbage collection, and it runs on every listing.
+    if (changed || next.size !== index.size)
+        writeIndex(next);
+    // A total order, not just a sort key. `updatedAt` is dominated by the log's
+    // mtime, and sessions written inside the same millisecond tie on it — which
+    // would leave their relative order down to whatever the backend happened to
+    // enumerate first, so the same history could list differently twice in a
+    // row. Creation time breaks the tie, and the id breaks that.
+    return summaries.sort((left, right) => right.updatedAt - left.updatedAt ||
+        right.createdAt - left.createdAt ||
+        (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+}
+/**
+ * Resolve one session's artifact path.
+ *
+ * Listing headers is a first-line-only read per log — about 2 ms across a
+ * fifty-session history — so the preview pane resolves its target this way
+ * rather than making every summary carry a filesystem path it has no business
+ * knowing about.
+ *
+ * @param source - The persistence service.
+ * @param sessionId - Session to locate.
+ * @returns The absolute artifact path, or undefined when the backend owns no
+ *   per-session file or the session is gone.
+ */
+export async function locateSession(source, sessionId, signal) {
+    let listed;
+    try {
+        listed = await enumerate(source, signal);
+    }
+    catch {
+        return undefined;
+    }
+    const match = listed.find(entry => entry.header.id === sessionId);
+    return match === undefined ? undefined : locate(source, match.raw, sessionId);
+}

package/lib/types/dsh-adapter/sessions/store.d.ts

@@ -0,0 +1,48 @@
+import type { TitleSource } from './types.js';
+/** Facts derived from a log at one revision. */
+export interface DerivedEntry {
+    readonly revision: string;
+    readonly title: string;
+    readonly titleSource: TitleSource;
+    readonly hasPrompt: boolean;
+    readonly model: string | undefined;
+    readonly label: string | undefined;
+}
+/** One session's cached record: derived facts plus this install's own notes. */
+export interface IndexEntry {
+    readonly derived: DerivedEntry | undefined;
+    /** Git branch this install was on when it last used the session. */
+    readonly branch: string | undefined;
+}
+/** The whole cache, session id → entry. */
+export type SessionIndex = Map<string, IndexEntry>;
+/**
+ * Load the cache.
+ * @returns The parsed index; an unreadable, malformed, or stale-schema file
+ *   yields an empty one, which costs a rebuild and never an error.
+ */
+export declare function readIndex(): SessionIndex;
+/**
+ * Persist the cache, atomically.
+ *
+ * The write goes to a per-process temporary name and is renamed into place, so
+ * a reader never observes a half-written file and a crash never leaves one.
+ * A concurrent writer may win the rename; the loser's derivations are simply
+ * recomputed next time.
+ *
+ * @param index - The index to store. Entries are written in insertion order.
+ */
+export declare function writeIndex(index: SessionIndex): void;
+/**
+ * Record the git branch this install is on for a session.
+ *
+ * Kept here rather than in the log because it is not a fact about the session,
+ * it is a fact about how this machine used it — the same reason it is reported
+ * as "branch when last used" and omitted entirely for sessions that predate
+ * the note. Inventing a branch for them would be worse than showing none.
+ *
+ * @param sessionId - Session being used.
+ * @param branch - Current branch, or undefined to leave any note untouched.
+ */
+export declare function noteBranch(sessionId: string, branch: string | undefined): void;
+//# sourceMappingURL=store.d.ts.map

package/lib/types/dsh-adapter/sessions/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/sessions/store.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAW7C,gDAAgD;AAChD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CACnC;AAED,gFAAgF;AAChF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CAAA;IAC1C,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC;AAED,2CAA2C;AAC3C,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;AAoClD;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,YAAY,CAkBxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAoBpD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAO9E"}

package/lib/types/dsh-adapter/sessions/store.js

@@ -0,0 +1,164 @@
+/**
+ * The session index — a local cache keyed by the backend's own change token.
+ *
+ * Deriving a session's title costs a bounded read; doing it for every session
+ * on every picker open costs that read times the history. The persistence
+ * service already hands out the exact token needed to avoid it:
+ * `listSnapshots()` returns, per session, an opaque revision that changes
+ * whenever the stored log changes. An entry whose revision still matches is
+ * reused verbatim; anything else is re-derived. Steady state is therefore zero
+ * log reads, and a session edited by another client (the store is shared with
+ * dsh web) invalidates itself without any coordination.
+ *
+ * The revision is treated as opaque, as its contract requires. It happens to
+ * be stat-derived today, but parsing it to shortcut a `stat` would couple this
+ * cache to one backend's private format and break the moment a store without
+ * per-session files is used.
+ *
+ * Two halves live in one entry because they have different lifetimes:
+ * `derived` facts come from the log and die with the revision, while `branch`
+ * is a local note about how this install used the session and no log change
+ * can invalidate it. Keeping them in one record with one governing revision
+ * field makes that boundary explicit instead of implied.
+ *
+ * Every operation is best-effort. The index is a cache: a corrupt file, a
+ * losing concurrent write, or a read-only home directory costs a re-derivation
+ * and nothing else, so nothing here throws.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/sessions/store
+ */
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DATA_DIR } from '../../utils/paths.js';
+/**
+ * Bumped when an entry's shape changes. A mismatch drops the whole file
+ * rather than migrating it — re-deriving is cheap and bounded, whereas a
+ * migration path is code that runs once and is never exercised again.
+ */
+const SCHEMA_VERSION = 1;
+const INDEX_FILE = join(DATA_DIR, 'session-index.json');
+/** A title source as written to disk, or undefined for anything unexpected. */
+function readTitleSource(value) {
+    return value === 'renamed' || value === 'auto' || value === 'prompt' || value === 'fallback'
+        ? value
+        : undefined;
+}
+/** Narrow one persisted entry; an unrecognizable record is simply absent. */
+function readEntry(value) {
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    const branch = typeof record['branch'] === 'string' ? record['branch'] : undefined;
+    const raw = record['derived'];
+    if (raw === null || typeof raw !== 'object')
+        return { derived: undefined, branch };
+    const derived = raw;
+    const revision = derived['revision'];
+    const title = derived['title'];
+    const titleSource = readTitleSource(derived['titleSource']);
+    if (typeof revision !== 'string' || typeof title !== 'string' || titleSource === undefined) {
+        return { derived: undefined, branch };
+    }
+    return {
+        branch,
+        derived: {
+            revision,
+            title,
+            titleSource,
+            hasPrompt: derived['hasPrompt'] === true,
+            model: typeof derived['model'] === 'string' ? derived['model'] : undefined,
+            label: typeof derived['label'] === 'string' ? derived['label'] : undefined,
+        },
+    };
+}
+/**
+ * Load the cache.
+ * @returns The parsed index; an unreadable, malformed, or stale-schema file
+ *   yields an empty one, which costs a rebuild and never an error.
+ */
+export function readIndex() {
+    const index = new Map();
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(INDEX_FILE, 'utf8'));
+    }
+    catch {
+        return index;
+    }
+    if (parsed === null || typeof parsed !== 'object')
+        return index;
+    const file = parsed;
+    if (file['version'] !== SCHEMA_VERSION)
+        return index;
+    const entries = file['entries'];
+    if (entries === null || typeof entries !== 'object')
+        return index;
+    for (const [id, value] of Object.entries(entries)) {
+        const entry = readEntry(value);
+        if (entry !== undefined)
+            index.set(id, entry);
+    }
+    return index;
+}
+/**
+ * Persist the cache, atomically.
+ *
+ * The write goes to a per-process temporary name and is renamed into place, so
+ * a reader never observes a half-written file and a crash never leaves one.
+ * A concurrent writer may win the rename; the loser's derivations are simply
+ * recomputed next time.
+ *
+ * @param index - The index to store. Entries are written in insertion order.
+ */
+export function writeIndex(index) {
+    const entries = {};
+    for (const [id, entry] of index) {
+        entries[id] = {
+            ...(entry.derived === undefined ? {} : { derived: entry.derived }),
+            ...(entry.branch === undefined ? {} : { branch: entry.branch }),
+        };
+    }
+    const temporary = `${INDEX_FILE}.${process.pid}.tmp`;
+    try {
+        mkdirSync(DATA_DIR, { recursive: true });
+        writeFileSync(temporary, JSON.stringify({ version: SCHEMA_VERSION, entries }));
+        renameSync(temporary, INDEX_FILE);
+    }
+    catch {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch {
+            // Nothing left to do; the cache stays as it was.
+        }
+    }
+}
+/**
+ * Record the git branch this install is on for a session.
+ *
+ * Kept here rather than in the log because it is not a fact about the session,
+ * it is a fact about how this machine used it — the same reason it is reported
+ * as "branch when last used" and omitted entirely for sessions that predate
+ * the note. Inventing a branch for them would be worse than showing none.
+ *
+ * @param sessionId - Session being used.
+ * @param branch - Current branch, or undefined to leave any note untouched.
+ */
+export function noteBranch(sessionId, branch) {
+    if (branch === undefined || branch.length === 0)
+        return;
+    const index = readIndex();
+    const existing = index.get(sessionId);
+    if (existing?.branch === branch)
+        return;
+    index.set(sessionId, { derived: existing?.derived, branch });
+    writeIndex(index);
+}
+/*
+ * Deliberately absent: a "forget this entry" call for the picker's delete, and
+ * a "patch this title" call for its rename. Listing prunes entries whose
+ * session no longer exists, and a renamed log has a new revision whose
+ * re-derivation reads the very title event the rename just appended — both
+ * paths already converge on the right answer, so a second mechanism to reach
+ * it could only disagree with the first.
+ */