@peasant-labs/fairtrade 0.0.18 → 0.0.20

package/dist/lib/graph.js

@@ -1,4 +1,4 @@
-import { $ as e, A as t, B as n, C as r, D as i, E as a, F as o, G as s, H as c, I as l, J as u, K as d, L as f, M as p, N as m, O as h, P as g, Q as _, R as v, S as y, T as b, U as x, V as S, W as C, X as w, Y as T, Z as E, _ as D, a as O, at as k, b as A, c as j, et as M, f as ee, g as N, h as P, ht as F, i as I, it as te, j as ne, k as re, m as ie, n as ae, nt as oe, o as se, ot as ce, pt as le, q as ue, r as de, rt as fe, s as pe, t as me, tt as he, ut as ge, v as L, w as _e, x as ve, xt as ye, y as be, z as xe } from "./GraphLegend-D9bZVLfT.js";
+import { $ as e, A as t, B as n, C as r, D as i, E as a, F as o, G as s, H as c, I as l, J as u, K as d, L as f, M as p, N as m, O as h, P as g, Q as _, R as v, S as y, T as b, U as x, V as S, W as C, X as w, Y as T, Z as E, _ as D, a as O, at as k, b as A, c as j, et as M, f as ee, g as N, h as P, ht as F, i as I, it as te, j as ne, k as re, m as ie, n as ae, nt as oe, o as se, ot as ce, pt as le, q as ue, r as de, rt as fe, s as pe, t as me, tt as he, ut as ge, v as L, w as _e, x as ve, xt as ye, y as be, z as xe } from "./GraphLegend-BB0V2w59.js";
 import { memo as Se, useCallback as R, useEffect as z, useMemo as B, useRef as V, useState as H } from "react";
 import { Fragment as Ce, jsx as U, jsxs as W } from "react/jsx-runtime";
 import { Box as we, Check as Te, ChevronDown as Ee, ChevronRight as G, Coins as De, CornerDownRight as Oe, FileCode as ke, FileDiff as Ae, FileText as je, Folder as Me, GitMerge as Ne, Hash as Pe, Map as Fe, Maximize2 as Ie, MessageSquare as Le, Minus as Re, Plus as ze, RotateCcw as Be, RotateCw as Ve, Search as He, Share2 as Ue, Tag as We, TriangleAlert as Ge, X as Ke } from "lucide-react";

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

@@ -1,9 +1,9 @@
 /**
  * resolve any accepted name/alias to a canonical mark key, or null when unknown.
  * @param {string} name
- * @returns {('claude'|'gemini'|'openai'|'cursor'|'opencode'|'strike')|null}
+ * @returns {('claude'|'gemini'|'openai'|'cursor'|'opencode'|'strike'|'pi')|null}
  */
-export function resolveBrand(name: string): ("claude" | "gemini" | "openai" | "cursor" | "opencode" | "strike") | null;
+export function resolveBrand(name: string): ("claude" | "gemini" | "openai" | "cursor" | "opencode" | "strike" | "pi") | null;
 /**
  * BrandMark - a single-color, currentColor-tinted company/provider logo.
  *

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/commons/providers.d.ts

@@ -4,4 +4,4 @@
 export function formatProvider(provider: unknown): string;
 /** @param {import('@peasant-labs/schema').Harness} provider */
 export function providerLabel(provider: import("@peasant-labs/schema").Harness): string;
-export const PROVIDER_LABEL: Readonly<Record<"strike" | "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity", string>>;
+export const PROVIDER_LABEL: Readonly<Record<"strike" | "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity" | "pi", 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/provider-policy.d.ts

@@ -12,7 +12,7 @@ export function providerBrand(harness: Harness): ProviderBrand;
 /** @param {Harness} harness @returns {ProviderAccent} */
 export function providerAccent(harness: Harness): ProviderAccent;
 /** @typedef {import('@peasant-labs/schema').Harness} Harness */
-/** @typedef {'claude'|'gemini'|'openai'|'opencode'|'cursor'|'strike'} ProviderBrand */
+/** @typedef {'claude'|'gemini'|'openai'|'opencode'|'cursor'|'strike'|'pi'} ProviderBrand */
 /** @typedef {'amber'|'teal'|'olive'|'mauve'|'clay'} ProviderAccent */
 /** @type {readonly Harness[]} */
 export const PROVIDER_HARNESSES: readonly Harness[];
@@ -23,5 +23,5 @@ export const PROVIDER_BRANDS: Readonly<Record<Harness, ProviderBrand>>;
 /** @type {Readonly<Record<Harness, ProviderAccent>>} */
 export const PROVIDER_ACCENTS: Readonly<Record<Harness, ProviderAccent>>;
 export type Harness = import("@peasant-labs/schema").Harness;
-export type ProviderBrand = "claude" | "gemini" | "openai" | "opencode" | "cursor" | "strike";
+export type ProviderBrand = "claude" | "gemini" | "openai" | "opencode" | "cursor" | "strike" | "pi";
 export type ProviderAccent = "amber" | "teal" | "olive" | "mauve" | "clay";

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

@@ -0,0 +1,9 @@
+/** @param {{usage?: import('@peasant-labs/schema').UsageDetail}} props */
+export default function UsageDisclosure({ usage }: {
+    usage?: import("@peasant-labs/schema").UsageDetail;
+}): import("react").JSX.Element;
+/** @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/analytics.d.ts

@@ -9,8 +9,7 @@
 /**
  * A "task" is the span from a top-level user prompt up to (but not including)
  * the next one — one turn of human↔agent collaboration. The shape is the
- * canonical `TaskGroup` the transcript-browser already exports, kept stable for
- * back-compat re-export.
+ * canonical `TaskGroup` shape, kept stable for consumer back-compat.
  * @typedef {object} TaskGroup
  * @property {number} startIndex          display position of the starting prompt
  * @property {number} endIndex            display position of the last turn (inclusive)
@@ -123,8 +122,7 @@ export type TranscriptAnalyticsVM = import("./view-model.js").TranscriptAnalytic
 /**
  * A "task" is the span from a top-level user prompt up to (but not including)
  * the next one — one turn of human↔agent collaboration. The shape is the
- * canonical `TaskGroup` the transcript-browser already exports, kept stable for
- * back-compat re-export.
+ * canonical `TaskGroup` shape, kept stable for consumer back-compat.
  */
 export type TaskGroup = {
     /**
@@ -176,8 +174,7 @@ export type PersonalMedians = {
 };
 /**
  * A session sample for personal-median computation — the QualitySession subset
- * the medians read. Kept structural so the transcript-browser `QualitySession`
- * is assignable for back-compat.
+ * the medians read. Kept structural for consumer back-compat.
  */
 export type PersonalMedianSession = {
     totalTokens: number;

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,11 +89,16 @@ 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
  * (no `@xyflow` dependency); in `viewMode: 'graph'` it hands the consumer this
- * cooked context and renders whatever the consumer returns (transcript-browser plugs its
+ * cooked context and renders whatever the consumer returns (a consuming app plugs
+ * fairtrade's own `/graph`
  */
 export type GraphSlotContext = {
     viewModel: import("./view-model.js").TranscriptViewModel;
@@ -150,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/usage.d.ts

@@ -0,0 +1,19 @@
+/** @param {import('@peasant-labs/schema').TurnDetail[]} turns
+ * @returns {import('./view-model.js').UsageScopeVM[]} */
+export function aggregateUsage(turns: import("@peasant-labs/schema").TurnDetail[]): import("./view-model.js").UsageScopeVM[];
+export const TOKEN_FIELDS: Readonly<{
+    input: "input";
+    output: "output";
+    cacheRead: "cache read";
+    cacheWrite: "cache write";
+    cacheWrite1h: "cache write 1h (subset)";
+    reasoning: "reasoning (subset)";
+    totalTokens: "total tokens";
+}>;
+export const COST_FIELDS: Readonly<{
+    input: "input";
+    output: "output";
+    cacheRead: "cache read";
+    cacheWrite: "cache write";
+    total: "total";
+}>;