@peasant-labs/fairtrade 0.0.19 → 0.0.20

package/dist/lib/types/Checkbox.d.ts

@@ -1,16 +1,26 @@
 /**
+ * A single checkbox - checked, unchecked, or mixed (indeterminate).
+ *
  * @typedef {Object} CheckboxProps
  * @property {boolean} [checked]        controlled checked state (pair with onChange)
  * @property {boolean} [defaultChecked] initial state for uncontrolled use (default false)
+ * @property {boolean} [indeterminate]  mixed state: draws a dash and reports the mixed
+ *                                      accessible state while `checked` stays false (default false)
  * @property {(checked: boolean, event: import('react').ChangeEvent<HTMLInputElement>) => void} [onChange]
  * @property {boolean} [disabled]       native disabled attribute (default false)
  * @property {import('react').ReactNode} [children] label text (rendered as passed, not lowercased)
  */
 /**
  * A single checkbox: <label class="check"> wrapping the styled <input type="checkbox" class="check-box">.
+ *
+ * `indeterminate` is a mixed state, distinct from checked: it renders its own dash and is exposed to
+ * assistive technology as `aria-checked="mixed"`, so the state is never carried by the mark alone.
+ * The mixed flag is not a DOM attribute on a native checkbox; it is the input's `indeterminate` IDL
+ * property, which is why the component owns a ref. A click on a mixed checkbox reports `true`, exactly
+ * as a plain unchecked checkbox would.
  * @param {CheckboxProps & import('react').InputHTMLAttributes<HTMLInputElement>} props
  */
-export default function Checkbox({ checked, defaultChecked, onChange, disabled, children, ...rest }: CheckboxProps & import("react").InputHTMLAttributes<HTMLInputElement>): import("react").JSX.Element;
+export default function Checkbox({ checked, defaultChecked, indeterminate, onChange, disabled, children, ...rest }: CheckboxProps & import("react").InputHTMLAttributes<HTMLInputElement>): import("react").JSX.Element;
 /**
  * @typedef {Object} RadioProps
  * @property {string} name              shared group name; radios must come in groups of >=2 so any one
@@ -53,6 +63,9 @@ export function Radio({ name, value, checked, defaultChecked, onChange, disabled
  * @param {RadioGroupProps & import('react').HTMLAttributes<HTMLDivElement>} props
  */
 export function RadioGroup({ name, value, defaultValue, onChange, options, ariaLabel, ...rest }: RadioGroupProps & import("react").HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+/**
+ * A single checkbox - checked, unchecked, or mixed (indeterminate).
+ */
 export type CheckboxProps = {
     /**
      * controlled checked state (pair with onChange)
@@ -62,6 +75,11 @@ export type CheckboxProps = {
      * initial state for uncontrolled use (default false)
      */
     defaultChecked?: boolean;
+    /**
+     * mixed state: draws a dash and reports the mixed
+     *   accessible state while `checked` stays false (default false)
+     */
+    indeterminate?: boolean;
     onChange?: (checked: boolean, event: import("react").ChangeEvent<HTMLInputElement>) => void;
     /**
      * native disabled attribute (default false)

package/dist/lib/types/HelperGroup.d.ts

@@ -0,0 +1,226 @@
+/**
+ * HelperGroup - a count chip inside one owner-anchored tree of saved threads.
+ *
+ * Presentation only: the host passes the complete authorized member set for the
+ * exact scope. No wire decoding, membership inference, fetching, paging, or
+ * selection storage occurs here. renderMember receives the original row,
+ * including its route-specific data.
+ *
+ * A helper tree is the ordinary row a host retained (`HelperGroupListItem`'s
+ * `owner`), the immediate groups that hang off it (`HelperGroup`), and the
+ * member rows those groups hold. The count chip sits ONE indent step inside the
+ * tree, between the owner row and the members it discloses, and carries no
+ * checkbox of its own. Members render only while the chip is open, each as a
+ * row like the owner's: title, middot facts, an individual checkbox, and
+ * host-authorized navigation.
+ *
+ * One continuous connector traces the centre of every MOUNTED row checkbox:
+ * verticals run in the parent's column, one square step lands on the deeper
+ * row's line, and one column is kept per depth, so a row the host never mounted
+ * is never traced. The connector is measured, never authored: mount,
+ * expand/collapse, a row that gains or loses its checkbox, and a resize all
+ * re-measure it.
+ *
+ * @param {object} props
+ * @param {string} props.groupId
+ * @param {string} props.memberScope - exact scope token the members belong to;
+ *   a changed scope resets uncontrolled disclosure, never inherits it
+ * @param {number} props.helperThreadCount - saved threads, never review/message totals
+ * @param {unknown[]} [props.members]
+ * @param {(row: any) => import('react').ReactNode} props.renderMember
+ * @param {(row: any) => string} props.getMemberKey - stable local/public transcript ID
+ * @param {boolean} [props.expanded] - controlled disclosure for host Back restoration
+ * @param {(expanded: boolean) => void} [props.onExpandedChange]
+ * @param {boolean} [props.scopeExpired] - fail-closed: hides members, offers only
+ *   an originating-list refresh, never loads anything broader
+ * @param {() => void} [props.onRefreshList] - refresh the originating query,
+ *   never an all-members fallback
+ * @param {(row: any) => boolean} [props.isMemberSelected] - host-owned selection
+ *   predicate; supply it whenever renderMember draws per-member checkboxes, so
+ *   the CLOSED control can state a selection the viewer cannot see
+ * @param {import('react').ReactNode} [props.memberFooter] - host-rendered slot
+ *   placed immediately after the member rows (or the empty notice) inside the
+ *   open body: THE canonical position for host paging controls ("page X of Y",
+ *   previous/next). Paging fetch, page/limit state, and the server counts stay
+ *   host-owned; the group never fetches, stores a page, or reads a scope token,
+ *   and renders the slot only while it is open and not scope-expired.
+ */
+export default function HelperGroup(props: {
+    groupId: string;
+    memberScope: string;
+    helperThreadCount: number;
+    members?: unknown[];
+    renderMember: (row: any) => import("react").ReactNode;
+    getMemberKey: (row: any) => string;
+    expanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+    scopeExpired?: boolean;
+    onRefreshList?: () => void;
+    isMemberSelected?: (row: any) => boolean;
+    memberFooter?: import("react").ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Roll one owner row and its helper members up into the owner checkbox state.
+ * The owner's own row is part of the rollup, so a tree whose owner is selected
+ * but whose members are not states `partial`, never a clean `checked`.
+ * @param {string|undefined|null} ownerId
+ * @param {Array<string|undefined|null>} memberIds
+ * @param {(id: string) => boolean} isSelected
+ * @returns {'checked'|'unchecked'|'partial'}
+ */
+export function helperOwnerState(ownerId: string | undefined | null, memberIds: Array<string | undefined | null>, isSelected: (id: string) => boolean): "checked" | "unchecked" | "partial";
+/**
+ * The selection state of one helper tree: the DISPLAYED selection is the whole
+ * tree while the select-all override is active, and the manual set otherwise.
+ * Selection STATE stays host-owned; this is the value useHelperSelection stores.
+ * @typedef {object} HelperSelectionState
+ * @property {boolean} allActive - true while the select-all override is engaged
+ * @property {Set<string>} manual - the configured and hand-picked selection
+ */
+/**
+ * The ids a tree currently DISPLAYS, owner first then members, or the manual set
+ * while the override is off. Ids are de-duplicated, and a missing owner (a
+ * helper-only result) is dropped.
+ * @param {HelperSelectionState} state
+ * @param {string|undefined|null} ownerId
+ * @param {Array<string|undefined|null>} memberIds
+ * @returns {string[]}
+ */
+export function helperSelectionIds(state: HelperSelectionState, ownerId: string | undefined | null, memberIds: Array<string | undefined | null>): string[];
+/**
+ * Toggle the owner checkbox: engage the all-selection from the manual side, or
+ * restore the manual selection from the all side. The manual set is never touched,
+ * so a manual member pick survives the cycle.
+ * @param {HelperSelectionState} state
+ * @returns {HelperSelectionState}
+ */
+export function helperOwnerToggle(state: HelperSelectionState): HelperSelectionState;
+/**
+ * Toggle one member checkbox. The write lands on the manual side and ends any
+ * all-selection: while the override is active the base is the DISPLAYED
+ * all-selection, so unticking one member keeps every other row selected and the
+ * next owner press restores all-but-that-member.
+ * @param {HelperSelectionState} state
+ * @param {string|undefined|null} ownerId
+ * @param {Array<string|undefined|null>} memberIds
+ * @param {string} memberId
+ * @param {boolean} checked
+ * @returns {HelperSelectionState}
+ */
+export function helperMemberToggle(state: HelperSelectionState, ownerId: string | undefined | null, memberIds: Array<string | undefined | null>, memberId: string, checked: boolean): HelperSelectionState;
+/**
+ * Hold the canonical helper-tree selection for one owner. The selection lives in
+ * the calling host, never in the components.
+ *
+ * A changed owner or member set is a different tree, so the hook resets to that
+ * tree's configured selection instead of carrying a pick across a scenario switch.
+ * @param {object} [config]
+ * @param {string} [config.ownerId] the tree's owner row id; omit for a
+ *   helper-only result, where every member selects on its own
+ * @param {string[]} [config.memberIds] every helper member under that owner
+ * @param {string[]} [config.initialSelectedIds] the configured manual selection
+ * @returns {{selectedIds: string[], isSelected: (id: string) => boolean,
+ *   ownerState: 'checked'|'unchecked'|'partial',
+ *   onSelect: (id: string, checked: boolean) => void}}
+ */
+export function useHelperSelection({ ownerId, memberIds, initialSelectedIds }?: {
+    ownerId?: string;
+    memberIds?: string[];
+    initialSelectedIds?: string[];
+}): {
+    selectedIds: string[];
+    isSelected: (id: string) => boolean;
+    ownerState: "checked" | "unchecked" | "partial";
+    onSelect: (id: string, checked: boolean) => void;
+};
+/**
+ * One owner-anchored helper tree: an ordinary row (or an explicit unavailable
+ * context) above its immediate helper groups, traced by ONE measured connector.
+ *
+ * The tree owns the connector, not the rows: every mounted row registers its
+ * element here, the tree measures the centre of each mounted row checkbox after
+ * each change and on resize, and the single path is drawn behind the rows. The
+ * connector is a selection aid only - it carries no meaning that the rows and
+ * their checkboxes do not already carry.
+ *
+ * For a helper-only result supply ownerStatus instead of owner; no fake title
+ * or owner action is rendered. Keep distinct unresolved containers keyed by
+ * backend group ID.
+ * @param {object} props
+ * @param {import('react').ReactNode} [props.owner]
+ * @param {string} [props.ownerStatus]
+ * @param {import('react').ReactNode} props.children - immediate HelperGroup children
+ */
+export function HelperGroupListItem({ owner, ownerStatus, children }: {
+    owner?: import("react").ReactNode;
+    ownerStatus?: string;
+    children: import("react").ReactNode;
+}): import("react").JSX.Element;
+/**
+ * One helper member drawn as the ordinary list row it is: title, a facts line
+ * with middot separators, an optional individual checkbox, and host-authorized
+ * navigation. Display-only when selection and navigation are both absent. The
+ * two optional behaviors are individual-only: a per-thread checkbox and
+ * host-authorized open navigation. No aggregate selection, no self-built links,
+ * no per-row disclosure. Hosts map scalar display props from their typed row and
+ * preserve route-specific status/usage/ordinary-child exits in children. These
+ * are UI props, not another wire DTO.
+ *
+ * Inside a helper tree the row registers itself so the tree can trace its
+ * checkbox; outside one it renders exactly as before. Because a host can turn
+ * selection off after mount, every render schedules a re-measure - the checkbox
+ * may have appeared or gone.
+ *
+ * Facts that have no measured value state that honestly ("unknown input
+ * submissions"), and a count of one singularizes: a row never claims "1 input
+ * submissions" or "1 turns". The separator falls BETWEEN facts that survive, so
+ * a row cannot open or end its facts line with a stray middot.
+ * @param {object} props
+ * @param {string} props.id - individual transcript identity, never a group ID
+ * @param {string} props.title - verbatim user content
+ * @param {string} [props.provider]
+ * @param {number} [props.inputSubmissionCount]
+ * @param {number} [props.turnCount]
+ * @param {string} [props.href] - host-created authorized route
+ * @param {(id: string, event: import('react').MouseEvent) => void} [props.onOpen]
+ * @param {boolean} [props.selected]
+ * @param {boolean} [props.selectionDisabled]
+ * @param {boolean} [props.indeterminate] - mixed state for a row that rolls
+ *   helper members up (the tree owner); ignored without `onSelect`
+ * @param {(id: string, selected: boolean) => void} [props.onSelect]
+ * @param {import('react').ReactNode} [props.children]
+ */
+export function HelperThreadRow({ id, title, provider, inputSubmissionCount, turnCount, href, onOpen, selected, selectionDisabled, indeterminate, onSelect, children }: {
+    id: string;
+    title: string;
+    provider?: string;
+    inputSubmissionCount?: number;
+    turnCount?: number;
+    href?: string;
+    onOpen?: (id: string, event: import("react").MouseEvent) => void;
+    selected?: boolean;
+    selectionDisabled?: boolean;
+    indeterminate?: boolean;
+    onSelect?: (id: string, selected: boolean) => void;
+    children?: import("react").ReactNode;
+}): import("react").JSX.Element;
+export namespace HELPER_OWNER_STATE {
+    let CHECKED: string;
+    let UNCHECKED: string;
+    let PARTIAL: string;
+}
+/**
+ * The selection state of one helper tree: the DISPLAYED selection is the whole
+ * tree while the select-all override is active, and the manual set otherwise.
+ * Selection STATE stays host-owned; this is the value useHelperSelection stores.
+ */
+export type HelperSelectionState = {
+    /**
+     * - true while the select-all override is engaged
+     */
+    allActive: boolean;
+    /**
+     * - the configured and hand-picked selection
+     */
+    manual: Set<string>;
+};

package/dist/lib/types/PromptDigest.d.ts

@@ -0,0 +1,36 @@
+/**
+ * PromptDigest — the prompts behind a pull request, rendered read-only from the schema type.
+ *
+ * @param {object} props
+ * @param {PromptDigestPayload} props.digest - the digest exactly as Village computed it. the
+ *        component renders the items it is given: it never builds, fetches, budgets, or collapses
+ *        a chain. a collapsed chain arrives as data, its session boundary items standing in for
+ *        the runs of prompts they hold.
+ * @param {(item: PromptDigestItemPayload) => string} [props.itemHref] - resolves one chain item to
+ *        its link target; the item's `kind` selects the destination (`session` -> the transcript on
+ *        Village, `prompt` and `skill` -> that turn in the shared transcript viewer, `commit` -> the
+ *        commit on GitHub). omit it and the chain renders as plain rows; the component owns no routes.
+ * @param {PromptAuthor} [props.author] - the writer of these prompts, supplied by the page (not
+ *        wire data). when given, every prompt row's avatar renders the writer's GitHub profile
+ *        photo via the existing `Avatar` family; when omitted, prompt rows keep today's generic
+ *        glyph.
+ * @param {string} [props.className] - extra classes appended after `.pd`
+ */
+export default function PromptDigest({ digest, itemHref, author, className, ...rest }: {
+    digest: PromptDigestPayload;
+    itemHref?: (item: PromptDigestItemPayload) => string;
+    author?: PromptAuthor;
+    className?: string;
+}): import("react").JSX.Element;
+export type PromptDigestPayload = import("@peasant-labs/schema").PromptDigest;
+export type PromptDigestItemPayload = import("@peasant-labs/schema").PromptDigestItem;
+export type PromptAuthor = {
+    /**
+     * - the GitHub login; also the avatar's accessible name.
+     */
+    login: string;
+    /**
+     * - the GitHub profile photo url.
+     */
+    avatarUrl: string;
+};

package/dist/lib/types/index.d.ts

@@ -18,6 +18,7 @@ export { default as PolicySelect } from "./PolicySelect.jsx";
 export { default as MapCanvas } from "./MapCanvas.jsx";
 export { default as StepsWaterfall } from "./StepsWaterfall.jsx";
 export { default as GroupedMultiSelect } from "./GroupedMultiSelect.jsx";
+export { default as PromptDigest } from "./PromptDigest.jsx";
 export { default as ToolCallRenderer } from "./ToolRenderers.jsx";
 export { default as Tour } from "./Tour.jsx";
 export { default as FacetRail } from "./FacetRail.jsx";
@@ -35,6 +36,7 @@ export { Avatar, AvatarGroup, Kbd, KbdChord, Tag } from "./Avatar.jsx";
 export { default as BrandMark, resolveBrand } from "./BrandMark.jsx";
 export { providerAccent, providerDisplayName } from "./provider-policy.js";
 export { Skeleton, Progress, Spinner, Toast, FeedbackPanel } from "./Feedback.jsx";
+export { default as HelperGroup, HelperGroupListItem, HelperThreadRow, useHelperSelection, helperOwnerState, helperSelectionIds, helperOwnerToggle, helperMemberToggle, HELPER_OWNER_STATE } from "./HelperGroup.jsx";
 export { default as Timeline, TimelineItem, ToolCall, ThinkingBlock } from "./Timeline.jsx";
 export { default as ToastProvider, useToast } from "./ToastHost.jsx";
 export { default as DateRange, DateRangeCalendar, formatRange, DATE_PRESETS } from "./DateRange.jsx";

package/dist/lib/types/transcript/TranscriptContext.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Current-source navigation and retained history use only cooked evidence.
+ * No parent fetch occurs when a reader opens an earlier section.
+ * @param {object} props
+ * @param {import('./view-model.js').RelationshipVM[]} [props.relationships]
+ * @param {import('./view-model.js').EarlierHistoryVM[]} [props.earlierHistory]
+ * @param {import('./state-capabilities.js').ViewerCallbacks['onNavigateRelationship']} [props.onNavigate]
+ * @param {Record<string, boolean>} props.open
+ * @param {(id: string) => void} props.toggle
+ * @param {Record<string, boolean>} props.openTools
+ * @param {(id: string) => void} props.toggleTool
+ */
+export default function TranscriptContext({ relationships, earlierHistory, onNavigate, open, toggle, openTools, toggleTool }: {
+    relationships?: import("./view-model.js").RelationshipVM[];
+    earlierHistory?: import("./view-model.js").EarlierHistoryVM[];
+    onNavigate?: import("./state-capabilities.js").ViewerCallbacks["onNavigateRelationship"];
+    open: Record<string, boolean>;
+    toggle: (id: string) => void;
+    openTools: Record<string, boolean>;
+    toggleTool: (id: string) => void;
+}): import("react").JSX.Element;

package/dist/lib/types/transcript/TranscriptViewer.d.ts

@@ -1,7 +1,7 @@
 /**
  * @param {TranscriptViewerProps} props
  */
-export default function TranscriptViewer({ viewModel, capabilities, callbacks, theme: themeProp, onThemeChange, graphSlot, activeTab: activeTabProp, onTabChange, viewMode: viewModeProp, onViewModeChange, leftRailOpen: leftRailOpenProp, onLeftRailOpenChange, rightRailOpen: rightRailOpenProp, onRightRailOpenChange, openTools: openToolsProp, onOpenToolsChange, initialPosition: initialPositionProp, activeTurn: activeTurnProp, onActiveTurnChange, search: searchProp, onSearchChange, filters: filtersProp, onFiltersChange, savedLabels: savedLabelsProp, onSavedLabelsChange, shareOpen: shareOpenProp, onShareOpenChange, moreOpen: moreOpenProp, onMoreOpenChange, breadcrumb, LinkComponent, renderTurnPanel, renderTurnActions, anchorHref, headerActions, streamPrelude, }: TranscriptViewerProps): import("react").JSX.Element;
+export default function TranscriptViewer({ viewModel, capabilities, callbacks, theme: themeProp, onThemeChange, graphSlot, activeTab: activeTabProp, onTabChange, viewMode: viewModeProp, onViewModeChange, leftRailOpen: leftRailOpenProp, onLeftRailOpenChange, rightRailOpen: rightRailOpenProp, onRightRailOpenChange, openTools: openToolsProp, onOpenToolsChange, earlierHistoryOpen: earlierHistoryOpenProp, onEarlierHistoryOpenChange, initialPosition: initialPositionProp, activeTurn: activeTurnProp, onActiveTurnChange, search: searchProp, onSearchChange, filters: filtersProp, onFiltersChange, savedLabels: savedLabelsProp, onSavedLabelsChange, shareOpen: shareOpenProp, onShareOpenChange, moreOpen: moreOpenProp, onMoreOpenChange, breadcrumb, LinkComponent, renderTurnPanel, renderTurnActions, anchorHref, headerActions, streamPrelude, }: TranscriptViewerProps): import("react").JSX.Element;
 export type TranscriptViewerProps = import("./state-capabilities.js").TranscriptViewerProps;
 export type TranscriptFilters = import("./state-capabilities.js").TranscriptFilters;
 export type TraceReadingSnapshot = {

package/dist/lib/types/transcript/UsageDisclosure.d.ts

@@ -2,7 +2,8 @@
 export default function UsageDisclosure({ usage }: {
     usage?: import("@peasant-labs/schema").UsageDetail;
 }): import("react").JSX.Element;
-/** @param {{scopes?: import('./view-model.js').UsageScopeVM[]}} props */
-export function UsageScopes({ scopes }: {
+/** @param {{scopes?: import('./view-model.js').UsageScopeVM[], label?: string}} props */
+export function UsageScopes({ scopes, label }: {
     scopes?: import("./view-model.js").UsageScopeVM[];
+    label?: string;
 }): import("react").JSX.Element;

package/dist/lib/types/transcript/adapter.d.ts

@@ -1,8 +1,8 @@
 /**
- * Default turn prefilter the adapter applies to `payload.turns`: drop turns with
- * neither content nor tool calls (and short tool-less system banners), then
- * collapse adjacent same-role turns with identical content (a streaming
- * artifact), preferring the tool-bearing copy. Pure, order-preserving. Exported
+ * Default turn prefilter the adapter applies independently per partition:
+ * preserve normalized evidence, including unknown provenance and folded refs.
+ * Only truly legacy rows lose empty/short banners or collapse equal adjacent
+ * content, preferring the tool-bearing copy. Pure, order-preserving. Exported
  * so a host that pre-scopes turns can run the SAME filter.
  * @param {TurnDetail[]} turns
  * @returns {TurnDetail[]}
@@ -59,4 +59,8 @@ export type AdaptTranscriptOptions = {
      * post-resolution projection by canonical turn index
      */
     visibleTurnIndices?: readonly number[];
+    /**
+     * separately authorized read metadata; never durable content
+     */
+    relationshipNavigation?: import("@peasant-labs/schema").SessionRelationshipNavigation[];
 };

package/dist/lib/types/transcript/index.d.ts

@@ -49,6 +49,9 @@ export type Theme = import("./state-capabilities.js").Theme;
 export type TranscriptTab = import("./state-capabilities.js").TranscriptTab;
 export type ViewMode = import("./state-capabilities.js").ViewMode;
 export type TranscriptViewModel = import("./view-model.js").TranscriptViewModel;
+export type RelationshipVM = import("./view-model.js").RelationshipVM;
+export type EarlierHistoryVM = import("./view-model.js").EarlierHistoryVM;
+export type AdaptTranscriptOptions = import("./adapter.js").AdaptTranscriptOptions;
 export type SessionVM = import("./view-model.js").SessionVM;
 export type SessionGitVM = import("./view-model.js").SessionGitVM;
 export type CommitVM = import("./view-model.js").CommitVM;

package/dist/lib/types/transcript/state-capabilities.d.ts

@@ -79,6 +79,8 @@ export type ViewerCapabilities = {
  * capability is true (see ViewerCapabilities). `onLabel` carries the popover's
  * cooked result; `onExport` carries the requested format. The viewer never
  * mutates the host's data — it reports intent through these.
+ * Relationship navigation is gated by authorized read evidence rather than a
+ * mutation capability; no usable target or no callback means no active control.
  */
 export type ViewerCallbacks = {
     onEdit?: () => void;
@@ -87,6 +89,10 @@ export type ViewerCallbacks = {
     onCopyLink?: () => void;
     onChangeVisibility?: () => void;
     onExport?: (format: "json" | "jsonl" | "markdown") => void;
+    /**
+     * authorized read target only; host owns current route and Back restoration
+     */
+    onNavigateRelationship?: (navigation: import("@peasant-labs/schema").SessionRelationshipNavigation) => void;
 };
 /**
  * What the `graphSlot` render-prop receives. The composite owns NO graph engine
@@ -151,6 +157,14 @@ export type TranscriptViewerProps = {
      */
     openTools?: Record<string, boolean>;
     onOpenToolsChange?: (openTools: Record<string, boolean>) => void;
+    /**
+     * section id to disclosure state, default closed
+     */
+    earlierHistoryOpen?: Record<string, boolean>;
+    /**
+     * persist with host route state for Back
+     */
+    onEarlierHistoryOpenChange?: (open: Record<string, boolean>) => void;
     /**
      * one-time position; null clears, and session/target/requestKey changes rearm
      */

package/dist/lib/types/transcript/view-model.d.ts

@@ -51,6 +51,10 @@
  * @property {number} tokensIn
  * @property {number} tokensOut
  * @property {number} turnCount
+ * @property {number} [inputSubmissionCount] absent means unmeasured, never inferred from turns
+ * @property {boolean} [hasNormalizedEvidence] prevents legacy prompt-derived title inference
+ * @property {import('@peasant-labs/schema').SessionPurpose} [purpose]
+ * @property {string} [rootSessionId]
  * @property {number} toolCallCount
  * @property {string} [title]               editorial session title/summary (render-when-present; else the consumer derives one from the first prompt). Not a wire field — supplied by a curated consumer.
  * @property {string} [project]
@@ -148,6 +152,16 @@ export type SessionVM = {
     tokensIn: number;
     tokensOut: number;
     turnCount: number;
+    /**
+     * absent means unmeasured, never inferred from turns
+     */
+    inputSubmissionCount?: number;
+    /**
+     * prevents legacy prompt-derived title inference
+     */
+    hasNormalizedEvidence?: boolean;
+    purpose?: import("@peasant-labs/schema").SessionPurpose;
+    rootSessionId?: string;
     toolCallCount: number;
     /**
      * editorial session title/summary (render-when-present; else the consumer derives one from the first prompt). Not a wire field — supplied by a curated consumer.
@@ -206,6 +220,14 @@ export type ToolCallVM = {
      * display name (e.g. "Read", "Bash")
      */
     name: string;
+    callEntryRef?: string;
+    resultEntryRef?: string;
+    callProvenance?: import("@peasant-labs/schema").ContentProvenance;
+    resultProvenance?: import("@peasant-labs/schema").ContentProvenance;
+    /**
+     * main or earlier-N, never a native coordinate
+     */
+    partition?: string;
     /**
      * separately recorded namespace; empty string remains present evidence
      */
@@ -270,6 +292,16 @@ export type ThinkingVM = {
  */
 export type TurnVM = {
     index: number;
+    /**
+     * partition-scoped stable rendering key
+     */
+    identity?: string;
+    /**
+     * main or earlier-N; main index navigation stays unchanged
+     */
+    partition?: string;
+    sourceEntryRef?: string;
+    provenance?: import("@peasant-labs/schema").ContentProvenance;
     role: import("./wire-types.js").Role;
     /**
      * display label, e.g. "1a" / "2"
@@ -607,6 +639,14 @@ export type TranscriptViewModel = {
      * render-when-present
      */
     analytics?: TranscriptAnalyticsVM;
+    /**
+     * authorized current-target navigation, cooked once
+     */
+    relationships?: RelationshipVM[];
+    /**
+     * separate index domains, collapsed by default
+     */
+    earlierHistory?: EarlierHistoryVM[];
     /**
      * non-conversational, including unattached records
      */
@@ -630,3 +670,21 @@ export type UsageScopeVM = {
     tokens: UsageFieldVM[];
     cost: UsageFieldVM[];
 };
+export type RelationshipVM = {
+    kind: import("@peasant-labs/schema").SessionRelationshipKind;
+    label: string;
+    statusLabel: string;
+    note?: string;
+    /**
+     * only usable, authorized targets
+     */
+    navigation?: import("@peasant-labs/schema").SessionRelationshipNavigation;
+};
+export type EarlierHistoryVM = {
+    id: string;
+    state: import("@peasant-labs/schema").EarlierHistoryState;
+    explanation: string;
+    turns: TurnVM[];
+    nativeMetadata?: import("@peasant-labs/schema").NativeMetadataRecord[];
+    usageScopes: UsageScopeVM[];
+};