@peasant-labs/fairtrade 0.0.1 → 0.0.3

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

@@ -0,0 +1,31 @@
+/**
+ * @param {object} props
+ * @param {TurnVM} [props.turn]
+ * @param {boolean} [props.active]
+ * @param {Record<string, boolean>} [props.openTools]   tool id → open?
+ * @param {(id: string) => void} [props.toggleTool]
+ * @param {(turnIndex: number) => void} [props.onCopyAnchor]
+ * @param {boolean} [props.copied]
+ * @param {(turnIndex: number, el: HTMLElement | null) => void} [props.registerRef]
+ * @param {(turnIndex: number) => void} [props.onLabel]   omit to hide the "label" affordance
+ * @param {{ outcome: string, flag?: string }} [props.savedLabel]
+ * @param {boolean} [props.compact]
+ * @param {boolean} [props.expandAll]
+ */
+export default function TurnCard({ turn, active, openTools, toggleTool, onCopyAnchor, copied, registerRef, onLabel, savedLabel, compact, expandAll, }: {
+    turn?: TurnVM;
+    active?: boolean;
+    openTools?: Record<string, boolean>;
+    toggleTool?: (id: string) => void;
+    onCopyAnchor?: (turnIndex: number) => void;
+    copied?: boolean;
+    registerRef?: (turnIndex: number, el: HTMLElement | null) => void;
+    onLabel?: (turnIndex: number) => void;
+    savedLabel?: {
+        outcome: string;
+        flag?: string;
+    };
+    compact?: boolean;
+    expandAll?: boolean;
+}): any;
+export type TurnVM = import("./view-model.js").TurnVM;

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

@@ -0,0 +1,11 @@
+/**
+ * @param {object} props
+ * @param {string} [props.label]      the switch label + its accessible name
+ * @param {boolean} [props.on]
+ * @param {Function} [props.onToggle]
+ */
+export default function ViewSwitch({ label, on, onToggle }: {
+    label?: string;
+    on?: boolean;
+    onToggle?: Function;
+}): any;

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

@@ -0,0 +1,90 @@
+/**
+ * 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
+ * so a host that pre-scopes turns can run the SAME filter.
+ * @param {TurnDetail[]} turns
+ * @returns {TurnDetail[]}
+ */
+export function prefilterTurns(turns: TurnDetail[]): TurnDetail[];
+/**
+ * Dependency-free line diff (LCS) → cooked `DiffLineVM[]`. fairtrade ships no
+ * `diff` package, so the adapter computes hunks itself. Line numbers are 1-based
+ * within the supplied snippet (the wire carries the edit snippet, not the file
+ * offset). Deterministic — no clock/randomness — so it is screenshot-stable.
+ * @param {string} oldText
+ * @param {string} newText
+ * @returns {DiffLineVM[]}
+ */
+export function diffLines(oldText: string, newText: string): DiffLineVM[];
+/**
+ * Project the canonical wire payload (folded turns) into the cooked
+ * `TranscriptViewModel` every dumb transcript component renders. The SOLE
+ * wire-parse + git-drift normalisation site.
+ *
+ * @param {TranscriptWireInput} payload          canonical wire; tolerates both git shapes
+ * @param {AnnotationSummary[]} [annotations]     separately-fetched entry annotations
+ * @param {TranscriptAnalyticsVM} [analytics]     precomputed analytics; else derived on demand
+ * @returns {TranscriptViewModel}
+ */
+export function adaptTranscript(payload: TranscriptWireInput, annotations?: AnnotationSummary[], analytics?: TranscriptAnalyticsVM): TranscriptViewModel;
+export type TranscriptWireInput = import("./wire-types.js").TranscriptWireInput;
+export type SessionDetailPayload = import("./wire-types.js").SessionDetailPayload;
+export type TurnDetail = import("./wire-types.js").TurnDetail;
+export type ToolCallDetail = import("./wire-types.js").ToolCallDetail;
+export type AnnotationSummary = import("./wire-types.js").AnnotationSummary;
+export type TranscriptViewModel = import("./view-model.js").TranscriptViewModel;
+export type TranscriptAnalyticsVM = import("./view-model.js").TranscriptAnalyticsVM;
+export type SessionVM = import("./view-model.js").SessionVM;
+export type SessionGitVM = import("./view-model.js").SessionGitVM;
+export type CommitVM = import("./view-model.js").CommitVM;
+export type TurnVM = import("./view-model.js").TurnVM;
+export type ToolCallVM = import("./view-model.js").ToolCallVM;
+export type ToolGroup = import("./view-model.js").ToolGroup;
+export type DiffLineVM = import("./view-model.js").DiffLineVM;
+export type DiffHunkVM = import("./view-model.js").DiffHunkVM;
+export type DiffEntryVM = import("./view-model.js").DiffEntryVM;
+export type FileEntryVM = import("./view-model.js").FileEntryVM;
+export type AnnotationVM = import("./view-model.js").AnnotationVM;
+export type HighlightVM = import("./view-model.js").HighlightVM;
+export type FilterIndexVM = import("./view-model.js").FilterIndexVM;
+export type PhaseVM = import("./view-model.js").PhaseVM;
+export type WireGitLike = {
+    branch?: string | null;
+    remote?: string | null;
+    /**
+     * TS-drift author (transcript.ts)
+     */
+    user?: string;
+    commits?: unknown[];
+};
+export type WireCommitLike = {
+    hash?: string;
+    message?: string;
+    /**
+     * Go shape (metadata.go)
+     */
+    authorName?: string;
+    /**
+     * Go shape, Unix millis
+     */
+    commitTime?: number;
+    /**
+     * TS-drift shape (transcript.ts)
+     */
+    timestamp?: string;
+    /**
+     * TS-drift per-commit churn
+     */
+    filesChanged?: number;
+    /**
+     * TS-drift per-commit churn
+     */
+    insertions?: number;
+    /**
+     * TS-drift per-commit churn
+     */
+    deletions?: number;
+    session?: boolean;
+};

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

@@ -0,0 +1,75 @@
+/** @typedef {import('./wire-types.js').ToolCallDetail} ToolCallDetail */
+/**
+ * The SOLE `JSON.parse` of a wire-encoded tool string in the lifted code. Every
+ * other parse helper here, the adapter, and the analytics util route through it,
+ * so a grep for `JSON.parse` of tool args/result yields exactly one hit. Returns
+ * `undefined` for empty or malformed input — callers degrade rather than throw.
+ *
+ * @param {string | undefined | null} raw
+ * @returns {unknown}
+ */
+export function parseJson(raw: string | undefined | null): unknown;
+/**
+ * Parse a tool call's `arguments` JSON string. Thin named entry point over the
+ * one `parseJson` site; the cooked `ToolCallVM.args` is this value (shape varies
+ * by tool, hence `unknown`).
+ * @param {string | undefined | null} raw
+ * @returns {unknown}
+ */
+export function parseArgs(raw: string | undefined | null): unknown;
+/**
+ * Parse a tool call's `result` JSON string. Thin named entry point over the one
+ * `parseJson` site; the cooked `ToolCallVM.output` is this value.
+ * @param {string | undefined | null} raw
+ * @returns {unknown}
+ */
+export function parseResult(raw: string | undefined | null): unknown;
+/**
+ * Extract the file path a tool call targets, preferring the wire `filePath`
+ * field and falling back to the common `file_path` / `path` / `notebook_path`
+ * argument keys. Consolidates the THREE duplicate `extractPath` definitions
+ * (tasks.ts, FilesView.tsx, file-rollup.ts) into one.
+ * @param {ToolCallDetail} call
+ * @returns {string | undefined}
+ */
+export function extractPath(call: ToolCallDetail): string | undefined;
+/**
+ * One old→new replacement inside an Edit / MultiEdit / NotebookEdit call.
+ * @typedef {object} EditPair
+ * @property {string} old_string
+ * @property {string} new_string
+ */
+/**
+ * The list of old→new replacements for an edit-family tool call: the `edits[]`
+ * array for MultiEdit, else the single `old_string` / `new_string` pair. Used by
+ * BOTH the diff-hunk builder (adapter) and the churn counter (`countDiff`), so
+ * the argument shape is parsed in exactly one place.
+ * @param {ToolCallDetail} call
+ * @returns {EditPair[]}
+ */
+export function editPairs(call: ToolCallDetail): EditPair[];
+/**
+ * The full-file body a Write tool call lays down (its `content` argument).
+ * @param {ToolCallDetail} call
+ * @returns {string}
+ */
+export function writeContent(call: ToolCallDetail): string;
+/**
+ * Lines inserted / removed for an edit-family or write tool call. Consolidates
+ * the THREE duplicate `countDiff` definitions. Pure: depends only on the parsed
+ * arguments, never a clock or the file system.
+ * @param {ToolCallDetail} call
+ * @returns {{ adds: number, dels: number }}
+ */
+export function countDiff(call: ToolCallDetail): {
+    adds: number;
+    dels: number;
+};
+export type ToolCallDetail = import("./wire-types.js").ToolCallDetail;
+/**
+ * One old→new replacement inside an Edit / MultiEdit / NotebookEdit call.
+ */
+export type EditPair = {
+    old_string: string;
+    new_string: string;
+};

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

@@ -0,0 +1,216 @@
+/** @typedef {import('./wire-types.js').TurnDetail} TurnDetail */
+/** @typedef {import('./wire-types.js').ToolCallDetail} ToolCallDetail */
+/** @typedef {import('./wire-types.js').SessionScorecard} SessionScorecard */
+/** @typedef {import('./view-model.js').PhaseVM} PhaseVM */
+/** @typedef {import('./view-model.js').ScorecardBandVM} ScorecardBandVM */
+/** @typedef {import('./view-model.js').AnnotationVM} AnnotationVM */
+/** @typedef {import('./view-model.js').TaskGroupVM} TaskGroupVM */
+/** @typedef {import('./view-model.js').TranscriptAnalyticsVM} TranscriptAnalyticsVM */
+/**
+ * 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.
+ * @typedef {object} TaskGroup
+ * @property {number} startIndex          display position of the starting prompt
+ * @property {number} endIndex            display position of the last turn (inclusive)
+ * @property {number} promptEntryIndex    wire entry index of the prompt (anchor)
+ * @property {number} [finalEntryIndex]   wire entry index of the final assistant turn
+ * @property {string} prompt              untruncated user prompt
+ * @property {number} toolCallCount
+ * @property {string[]} filesTouched
+ * @property {number} insertions
+ * @property {number} deletions
+ * @property {number} durationMs
+ * @property {boolean} hasErrors
+ * @property {number} tokens
+ */
+/**
+ * Split a turn list into task groups. Each top-level (depth-0) user turn starts
+ * a new task; depth-1+ user turns are content blocks, NOT boundaries. A session
+ * that starts without a user prompt is a single task spanning everything.
+ * @param {TurnDetail[]} turns
+ * @returns {TaskGroup[]}
+ */
+export function computeTasks(turns: TurnDetail[]): TaskGroup[];
+/**
+ * Per-turn display labels: `"1"`, `"2"` for the prompts that open a task, and
+ * `"2a"`, `"2b"` for the follow-ups within it.
+ * @param {TurnDetail[]} turns
+ * @returns {string[]}
+ */
+export function computeTurnLabels(turns: TurnDetail[]): string[];
+/**
+ * One segment of the proportional task waterfall: a task's share of the total
+ * work time and the cumulative share before it (segments tile back-to-back).
+ * @typedef {object} WaterfallSegment
+ * @property {number} promptEntryIndex
+ * @property {number} offsetPct
+ * @property {number} widthPct
+ * @property {number} durationMs
+ */
+/**
+ * Turn task groups into a relative-duration lane. When the total duration is 0
+ * (untimed transcript) every segment is zero-width at offset 0 — the caller
+ * renders the task list without bars rather than dividing by zero.
+ * @param {TaskGroup[]} tasks
+ * @returns {WaterfallSegment[]}
+ */
+export function buildTaskWaterfall(tasks: TaskGroup[]): WaterfallSegment[];
+/**
+ * Walk a transcript and surface error / retry / revert / subagent moments,
+ * sorted by display position.
+ * @param {TurnDetail[]} turns
+ * @returns {TranscriptAnnotation[]}
+ */
+export function annotateTranscript(turns: TurnDetail[]): TranscriptAnnotation[];
+/** Display label for a phase type, falling back to the raw value. @param {string} type @returns {string} */
+export function phaseLabel(type: string): string;
+/**
+ * Segment a transcript into rendered phases. `from` / `to` are WIRE turn indices
+ * (matching `TurnVM.index`), so a divider component can anchor by them directly.
+ * @param {TurnDetail[]} turns
+ * @returns {PhaseVM[]}
+ */
+export function detectPhases(turns: TurnDetail[]): PhaseVM[];
+/**
+ * Per-metric medians across the user's sessions, each field undefined when the
+ * sample yields no value (so the comparison line degrades rather than fabricate
+ * a baseline). The host supplies the sessions; the viewer never fetches them.
+ * @param {PersonalMedianSession[] | undefined} sessions
+ * @returns {PersonalMedians}
+ */
+export function computePersonalMedians(sessions: PersonalMedianSession[] | undefined): PersonalMedians;
+/**
+ * Derive the three scorecard axis verdict bands (token / prompt / loop
+ * efficiency) from the raw numeric signals. Returns `[]` when the scorecard
+ * carries no usable signal, so the card is omitted cleanly.
+ * @param {SessionScorecard | null | undefined} sc
+ * @param {PersonalMedians} [medians]
+ * @returns {ScorecardBandVM[]}
+ */
+export function assessScorecard(sc: SessionScorecard | null | undefined, medians?: PersonalMedians): ScorecardBandVM[];
+/**
+ * The cooked task groups for a turn list (`computeTasks` mapped onto
+ * `TaskGroupVM`). Exported so the adapter can populate the always-present
+ * `vm.tasks` from the same single computation `computeAnalytics` uses.
+ * @param {TurnDetail[]} turns
+ * @returns {TaskGroupVM[]}
+ */
+export function computeTaskGroups(turns: TurnDetail[]): TaskGroupVM[];
+/**
+ * Compute the cooked single-session analytics block from a (prefiltered) turn
+ * list. Each field is omitted when empty so the block is genuinely
+ * render-when-present. The adapter calls this on demand when no precomputed
+ * analytics is supplied, and reuses the returned `patternAnnotations` /
+ * `taskGroups` so nothing is derived twice.
+ * @param {TurnDetail[]} turns
+ * @param {{ scorecard?: SessionScorecard | null, medians?: PersonalMedians }} [opts]
+ * @returns {TranscriptAnalyticsVM}
+ */
+export function computeAnalytics(turns: TurnDetail[], opts?: {
+    scorecard?: SessionScorecard | null;
+    medians?: PersonalMedians;
+}): TranscriptAnalyticsVM;
+export type TurnDetail = import("./wire-types.js").TurnDetail;
+export type ToolCallDetail = import("./wire-types.js").ToolCallDetail;
+export type SessionScorecard = import("./wire-types.js").SessionScorecard;
+export type PhaseVM = import("./view-model.js").PhaseVM;
+export type ScorecardBandVM = import("./view-model.js").ScorecardBandVM;
+export type AnnotationVM = import("./view-model.js").AnnotationVM;
+export type TaskGroupVM = import("./view-model.js").TaskGroupVM;
+export type TranscriptAnalyticsVM = import("./view-model.js").TranscriptAnalyticsVM;
+/**
+ * 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.
+ */
+export type TaskGroup = {
+    /**
+     * display position of the starting prompt
+     */
+    startIndex: number;
+    /**
+     * display position of the last turn (inclusive)
+     */
+    endIndex: number;
+    /**
+     * wire entry index of the prompt (anchor)
+     */
+    promptEntryIndex: number;
+    /**
+     * wire entry index of the final assistant turn
+     */
+    finalEntryIndex?: number;
+    /**
+     * untruncated user prompt
+     */
+    prompt: string;
+    toolCallCount: number;
+    filesTouched: string[];
+    insertions: number;
+    deletions: number;
+    durationMs: number;
+    hasErrors: boolean;
+    tokens: number;
+};
+/**
+ * One segment of the proportional task waterfall: a task's share of the total
+ * work time and the cumulative share before it (segments tile back-to-back).
+ */
+export type WaterfallSegment = {
+    promptEntryIndex: number;
+    offsetPct: number;
+    widthPct: number;
+    durationMs: number;
+};
+export type FailedAttempt = {
+    tools: string[];
+    turnRange: [number, number];
+};
+export type PersonalMedians = {
+    retryShare?: number;
+    specQualityScore?: number;
+    withinSessionReverts?: number;
+};
+/**
+ * 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.
+ */
+export type PersonalMedianSession = {
+    totalTokens: number;
+    retryTokensWasted: number;
+    specQualityScore: number;
+    withinSessionReverts: number;
+};
+/**
+ * A client-side detected pattern moment. Canonical `TranscriptAnnotation` shape
+ * kept stable for back-compat re-export.
+ */
+export type TranscriptAnnotation = {
+    /**
+     * display position
+     */
+    turnIndex: number;
+    type: "retry" | "error" | "revert" | "subagent";
+    label: string;
+    severity: "info" | "warning" | "error";
+};
+export type PhaseType = "planning" | "exploration" | "implementation" | "testing" | "error" | "debug" | "retry-loop" | "user-correction" | "recovery" | "abandonment";
+export type PhaseSegment = {
+    type: PhaseType;
+    /**
+     * display position (inclusive)
+     */
+    startTurn: number;
+    /**
+     * display position (inclusive)
+     */
+    endTurn: number;
+    badges: {
+        type: PhaseType;
+        count: number;
+    }[];
+};

package/dist/lib/types/transcript/graph/GraphLegend.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The trajectory-graph legend visual.
+ * @param {GraphLegendProps} props
+ * @returns {JSX.Element}
+ */
+export function GraphLegend({ items, className }: GraphLegendProps): JSX.Element;
+/**
+ * One legend entry.
+ * @typedef {object} GraphLegendItem
+ * @property {'user' | 'assistant' | 'subagent' | 'tool' | 'error' | (string & {})} kind
+ *   the node kind this swatch stands for; selects the accent
+ * @property {string} label                    the lowercase word shown beside the swatch
+ * @property {string} [provider]               harness key → assistant swatch accent
+ */
+/**
+ * @typedef {object} GraphLegendProps
+ * @property {GraphLegendItem[]} [items]       legend entries (defaults to GRAPH_LEGEND_ITEMS)
+ * @property {string} [className]
+ */
+/** The canonical legend set, in display order — mirrors the mockup's legend. */
+export const GRAPH_LEGEND_ITEMS: readonly {
+    kind: string;
+    label: string;
+}[];
+export default GraphLegend;
+/**
+ * One legend entry.
+ */
+export type GraphLegendItem = {
+    /**
+     *   the node kind this swatch stands for; selects the accent
+     */
+    kind: "user" | "assistant" | "subagent" | "tool" | "error" | (string & {});
+    /**
+     * the lowercase word shown beside the swatch
+     */
+    label: string;
+    /**
+     * harness key → assistant swatch accent
+     */
+    provider?: string;
+};
+export type GraphLegendProps = {
+    /**
+     * legend entries (defaults to GRAPH_LEGEND_ITEMS)
+     */
+    items?: GraphLegendItem[];
+    className?: string;
+};

package/dist/lib/types/transcript/graph/GraphSubagentBranch.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @typedef {object} GraphSubagentBranchProps
+ * @property {string} agentName                the nested agent's name (user content)
+ * @property {number} depth                    nesting depth (1 = first level under the main lane)
+ * @property {string} [className]
+ */
+/**
+ * The subagent swimlane header visual.
+ * @param {GraphSubagentBranchProps} props
+ * @returns {JSX.Element}
+ */
+export function GraphSubagentBranch({ agentName, depth, className }: GraphSubagentBranchProps): JSX.Element;
+export default GraphSubagentBranch;
+export type GraphSubagentBranchProps = {
+    /**
+     * the nested agent's name (user content)
+     */
+    agentName: string;
+    /**
+     * nesting depth (1 = first level under the main lane)
+     */
+    depth: number;
+    className?: string;
+};

package/dist/lib/types/transcript/graph/GraphToolNode.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The trajectory-graph tool-cluster pill visual.
+ * @param {GraphToolNodeProps} props
+ * @returns {JSX.Element}
+ */
+export function GraphToolNode({ tools, totalDurationMs, hasError, isFilteredOut, max, className, }: GraphToolNodeProps): JSX.Element;
+export default GraphToolNode;
+/**
+ * One cooked tool entry for the cluster. A strict presentational subset of
+ * ToolCallVM — note the absence of any raw wire `arguments`/`result` string, by
+ * design, so the visual cannot parse wire JSON.
+ */
+export type GraphToolItem = {
+    id: string;
+    /**
+     * display name (e.g. "Read", "Bash")
+     */
+    name: string;
+    /**
+     * tool kind (decorative grouping hint)
+     */
+    kind?: string;
+    /**
+     * cooked path; basename is the preview fallback
+     */
+    filePath?: string;
+    /**
+     * cooked one-line arg summary (NEVER parsed here)
+     */
+    preview?: string;
+    isError?: boolean;
+    exitCode?: number;
+};
+export type GraphToolNodeProps = {
+    /**
+     * the cooked tool calls for this turn
+     */
+    tools: GraphToolItem[];
+    /**
+     * summed duration → header badge
+     */
+    totalDurationMs?: number;
+    /**
+     * cluster carries a failed call
+     */
+    hasError?: boolean;
+    /**
+     * engine: dimmed by an active filter
+     */
+    isFilteredOut?: boolean;
+    /**
+     * rows before collapsing to "+ N more" (default 4)
+     */
+    max?: number;
+    className?: string;
+};

package/dist/lib/types/transcript/graph/GraphTurnNode.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The trajectory-graph turn card visual.
+ * @param {GraphTurnNodeProps} props
+ * @returns {JSX.Element}
+ */
+export function GraphTurnNode({ role, agentName, turnNumber, contentPreview, toolCount, totalTokens, tokensIn, tokensOut, hasError, hasRetry, hasRevert, isSearchMatch, isFilteredOut, isSelected, provider, className, }: GraphTurnNodeProps): JSX.Element;
+export default GraphTurnNode;
+export type Role = import("../wire-types.js").Role;
+/**
+ * Cooked, engine-agnostic props for one trajectory-graph turn card. Every field
+ * is a finished display value — the component does no parsing, truncation, or
+ * data derivation beyond choosing the accent token and chrome label.
+ */
+export type GraphTurnNodeProps = {
+    /**
+     * canonical role; selects the chrome label + base accent
+     */
+    role: Role;
+    /**
+     * subagent name; PRESENT ⇒ render as a subagent (mauve)
+     */
+    agentName?: string;
+    /**
+     * the display number shown as "#…"
+     */
+    turnNumber: string | number;
+    /**
+     * one-line, already-truncated preview (may be empty)
+     */
+    contentPreview: string;
+    /**
+     * tool-call count for the footer ("N tools")
+     */
+    toolCount: number;
+    /**
+     * total tokens for the footer badge
+     */
+    totalTokens: number;
+    /**
+     * optional split, surfaced via title for hover detail
+     */
+    tokensIn?: number;
+    tokensOut?: number;
+    /**
+     * clay accent + error flag (highest-priority flag)
+     */
+    hasError?: boolean;
+    /**
+     * "retry" flag (when not an error)
+     */
+    hasRetry?: boolean;
+    /**
+     * "re-edit" flag (when not an error or retry)
+     */
+    hasRevert?: boolean;
+    /**
+     * engine: highlighted as a search hit
+     */
+    isSearchMatch?: boolean;
+    /**
+     * engine: dimmed because a filter excludes it
+     */
+    isFilteredOut?: boolean;
+    /**
+     * engine: the active/selected node
+     */
+    isSelected?: boolean;
+    /**
+     * harness key (e.g. "claude-code") → assistant accent
+     */
+    provider?: string;
+    /**
+     * extra classes appended after the base
+     */
+    className?: string;
+};

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

@@ -0,0 +1,10 @@
+export { GraphTurnNode } from "./GraphTurnNode.jsx";
+export { GraphToolNode } from "./GraphToolNode.jsx";
+export { GraphSubagentBranch } from "./GraphSubagentBranch.jsx";
+export type GraphTurnNodeProps = import("./GraphTurnNode.jsx").GraphTurnNodeProps;
+export type GraphToolNodeProps = import("./GraphToolNode.jsx").GraphToolNodeProps;
+export type GraphToolItem = import("./GraphToolNode.jsx").GraphToolItem;
+export type GraphSubagentBranchProps = import("./GraphSubagentBranch.jsx").GraphSubagentBranchProps;
+export type GraphLegendProps = import("./GraphLegend.jsx").GraphLegendProps;
+export type GraphLegendItem = import("./GraphLegend.jsx").GraphLegendItem;
+export { GraphLegend, GRAPH_LEGEND_ITEMS } from "./GraphLegend.jsx";