( filterName: string, parent: string | undefined, params: Record<string, unknown>, schema: ParamsSchem

( input: unknown, now: number, )

( name: string, params: Record<string, unknown>, schema: object, )

(profile: ProjectProfileSummary)

(input: unknown, now: number)

(p: QueryFilter, filters: Map<string, Filter>)

()

( experiment: Experiment, now = Date.now(), )

(value: unknown)

(value: unknown)

()

(path: string, rolloutPath: string)

({ mix }: { mix: Array<{ agent: string; count: number }> })

()

({ id, onBack, onOpenSession }: Props)

({ label, hint, children, }: { label: string; hint?: string; children: React.ReactNode; })

({ artifactId, onBack, onOpenArtifact, }: { artifactId: string; onBack: () => void; onOpenArtifact

({ cohortType, connector, onBack, onOpenArtifact, }: { cohortType: string; connector?: string; o

({ count }: { count: number })

()

({ contributions }: { contributions: HeaderStats['contributions'] })

({ sessionId, events, loading, }: { sessionId: string; events: TranscriptEvent[] | null; loading:

({ label, value }: { label: string; value: string })

({ cost, loading }: { cost: SessionCostResult | null; loading: boolean })

({ progress, onReindex, onOpenSession, onOpenSessions, onOpenProject, }: Props)

({ ev, expanded, onToggleExpanded, }: { ev: TranscriptEvent; expanded: boolean; onToggleExpanded:

({ ts }: { ts?: number })

({ expanded, onClick }: { expanded: boolean; onClick: () => void })

({ experiment }: { experiment: Experiment })

({ selectedHypothesis, experiments, loading, }: { selectedHypothesis: Hypothesis | null; experiments

({ items }: { items: Insights['dayKinds'] })

({ hypotheses, experiments, selectedHypothesisId, loading, onSelect, }: { hypotheses: Hypothesis[]

({ hypothesis, experimentCount, selected, onSelect, }: { hypothesis: Hypothesis; experimentCount:

({ hypothesis, experimentCount, selected, onSelect, }: { hypothesis: Hypothesis; experimentCount:

({ onOpenSession }: Props)

({ locator }: { locator: string | null })

({ member, badge, onOpenArtifact, }: { member: CohortMember; badge?: string; onOpenArtifact: (id:

({ ev }: { ev: TranscriptEvent })

({ streaks, records, }: { streaks: HeaderStats['streaks']; records: Insights['personalRecords'] | null

({ overview, onCopy, }: { overview: RewardOverview; onCopy: (text: string) => void; })

({ records, workRhythm, onOpenSession, }: { records: Insights['personalRecords']; workRhythm: Insigh

({ overview, loading, onCopy, }: { overview: RewardProjectOverview | null; loading: boolean; onCop

({ items, onOpenProject, }: { items: ProjectSummary[]; onOpenProject: (id: string) => void; })

({ item, onBack }: { item: RewardProjectOverview; onBack: () => void })

({ projects, onOpenProjects, }: { projects: RewardProjectOverview[]; onOpenProjects: () => void; })

({ title, empty, items, renderMeta, }: { title: string; empty: string; items: T[]; renderMeta:

({ activeProjects, repeatedReturnProjects, comebackProjects, }: { activeProjects: WindowBundle['window

({ projects, onBack, onOpenProject, }: { projects: RewardProjectOverview[]; onBack: () => void; on

({ projects, onOpenProject, }: { projects: RewardProjectOverview[]; onOpenProject: (id: string) => voi

({ item, onOpenProject, }: { item: RewardProjectOverview; onOpenProject: (id: string) => void; })

({ id, onBack }: Props)

({ items, empty, onOpenProject, }: { items: RewardProjectOverview[]; empty: string; onOpenProject:

({ onSaved }: Props)

({ id, onBack, onDeleted }: Props)

({ recentSessions, onOpenSession, onOpenSessions, }: { recentSessions: HeaderStats['recentSessions'];

({ label, value, detail, title, }: { label: string; value: string; detail?: string; title?: st

({ experiment }: { experiment: Experiment })

({ selectedHypothesis, experiments, loading, }: { selectedHypothesis: Hypothesis | null; experiments

({ hypotheses, experiments, selectedHypothesisId, loading, onSelect, }: { hypotheses: Hypothesis[]

({ item }: { item: RewardProjectOverview })

({ targets }: { targets: RewardTargetSeries[] })

({ onOpenSession }: Props)

({ overview, onOpenType, }: { overview: RewardOverview; onOpenType: (type: string) => void; })

({ children }: { children: React.ReactNode })

({ session, onClick, href }: SessionCardProps)

({ session, onBack }: { session: Session; onBack: () => void })

({ id, onBack }: Props)

({ search, onOpen }: Props)

({ view, setView, queries, search, setSearch, progress, onReindex }: Props)

({ session }: { session: Session })

({ thread, projectName, externalization, rewards, onOpenSession, }: Props)

({ label, value }: { label: string; value: number | string })

({ totals }: { totals: TokenTotals })

({ row, expanded, onToggleExpanded, }: { row: Extract<TranscriptDisplayRow, { type: 'tool' }>; expan

({ label, text }: { label: string; text: string })

({ label, value }: { label: string; value: number })

({ totals }: { totals: HeaderStats['totals'] })

({ type, onBack, onOpenThread, }: { type: string; onBack: () => void; onOpenThread: (id: string) =

({ windowDays, setWindowDays, data, }: { windowDays: WindowDays; setWindowDays: (d: WindowDays) => v

({ cells, rhythm, }: { cells: Insights['hourDowHeatmap']; rhythm: Insights['workRhythm']; })

({ id, onBack, onOpenSession }: Props)

()

()

()

()

(q: QueryDefinition)

(member: CohortMember)

(message: string)

(text: string)

()

(text: string)

()

()

()

()

()

(parentSessionId: string)

(parentSessionId: string)

(parentSessionId: string)

(parentSessionId: string)