@yieldfabric/terminal 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2308 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import { NodeProps, EdgeProps, Node, Edge } from '@xyflow/react';
+
+/** Reply-path override surfaced in the chat input toolbar. Maps to the
+ *  backend's `reasoning` field on `POST /chat`:
+ *    - `null`     — default; the intent classifier decides whether to
+ *                   invoke a deep reasoning pass.
+ *    - `'reason'` — `reasoning: true`; force deep collaborative reasoning,
+ *                   bypassing the classifier.
+ *
+ *  The vocabulary editor and similar fast-response contexts use
+ *  `reasoning: false` directly in their request body — there is no toggle
+ *  state for that since it's a per-context decision, not a user choice. */
+type ReasoningMode = 'reason';
+
+interface TerminalTheme {
+    primary: string;
+    primaryMuted: string;
+    primaryHover: string;
+    bgBase: string;
+    bgRaised: string;
+    bgRaisedAlt: string;
+    bgRaisedHover: string;
+    bgOverlay: string;
+    bgHeader: string;
+    bgInput: string;
+    border: string;
+    borderLight: string;
+    borderStrong: string;
+    text: string;
+    textSecondary: string;
+    textMuted: string;
+    textInverse: string;
+    success: string;
+    error: string;
+    warning: string;
+    info: string;
+    textSystem: string;
+    textCommand: string;
+    textResponse: string;
+    codeBg: string;
+    codeText: string;
+    headingText: string;
+    buttonBg: string;
+    buttonHover: string;
+    buttonUploadBg: string;
+    buttonFilesBg: string;
+    buttonShadow: string;
+    scopeBorder: string;
+    scopeBg: string;
+    collabBorder: string;
+    collabBg: string;
+    reasoningBorder: string;
+    reasoningBg: string;
+    reasoningAccent: string;
+    pipelineBg: string;
+    shadowModal: string;
+    shadowDropdown: string;
+    radius: string;
+    radiusSm: string;
+    radiusLg: string;
+    cursor: string;
+}
+declare const defaultTheme: TerminalTheme;
+declare const TerminalThemeProvider: React.Provider<TerminalTheme>;
+declare function useTheme(): TerminalTheme;
+declare function mergeTheme(overrides?: Partial<TerminalTheme>): TerminalTheme;
+/** @deprecated Use useTheme() or defaultTheme instead */
+declare const purple: {
+    readonly border: string;
+    readonly borderLight: string;
+    readonly borderMedium: string;
+    readonly borderStrong: string;
+    readonly borderHeavy: "rgba(51, 51, 51, 0.8)";
+    readonly borderExtraLight: "rgba(40, 40, 40, 0.4)";
+    readonly borderHighlight: string;
+    readonly bg: string;
+    readonly bgLight: string;
+    readonly bgMedium: string;
+    readonly bgStrong: string;
+    readonly bgHeavy: "rgba(51, 51, 51, 0.6)";
+    readonly bgButton: string;
+    readonly bgDark: "#181818";
+    readonly bgDarker: "#181818";
+    readonly bgHover: string;
+    readonly text: string;
+    readonly textMuted: string;
+};
+/** @deprecated Use useTheme() or defaultTheme instead */
+declare const greenAction: {
+    readonly border: "border-green-800/50";
+    readonly borderStyle: "1px solid rgba(22, 101, 52, 0.5)";
+    readonly bg: "rgba(20, 80, 40, 0.2)";
+    readonly bgHover: "rgba(20, 100, 50, 0.3)";
+};
+/** @deprecated Use useTheme() or defaultTheme instead */
+declare const warmBg: {
+    readonly header: string;
+    readonly card: "rgba(50, 45, 40, 0.90)";
+    readonly cardAlt: string;
+    readonly cardHover: string;
+    readonly button: string;
+    readonly buttonHover: string;
+    readonly buttonUpload: string;
+    readonly buttonFiles: string;
+};
+/** @deprecated Use useTheme() or defaultTheme instead */
+declare const orangeRebuttal: {
+    readonly border: string;
+    readonly borderLight: "rgba(251, 146, 60, 0.15)";
+    readonly bg: "rgba(251, 146, 60, 0.05)";
+    readonly bgCard: "rgba(251, 146, 60, 0.06)";
+};
+/** @deprecated Use useTheme() or defaultTheme instead */
+declare const emeraldRevised: {
+    readonly border: "rgba(52, 211, 153, 0.25)";
+    readonly bg: "rgba(52, 211, 153, 0.05)";
+};
+/** @deprecated Use useTheme() or defaultTheme instead */
+declare const blueScope: {
+    readonly border: string;
+    readonly bg: string;
+};
+/** @deprecated Use useTheme() or defaultTheme instead */
+declare const emeraldCollab: {
+    readonly border: string;
+    readonly bg: string;
+};
+/** @deprecated Use useTheme() or defaultTheme instead */
+declare const pipelineBg: string;
+/** @deprecated Use defaultTheme.buttonShadow instead */
+declare const buttonShadow: string;
+/** @deprecated Use useTheme() or defaultTheme instead */
+declare const hostApp: {
+    readonly bg: "#181818";
+    readonly bgCard: string;
+    readonly bgCardAlt: string;
+    readonly bgSurface: string;
+    readonly border: string;
+    readonly borderLight: string;
+    readonly primary: string;
+    readonly textPrimary: string;
+    readonly textSecondary: string;
+    readonly textMuted: string;
+};
+
+interface AIAction {
+    action_type: string;
+    payload: any;
+    description?: string;
+    metadata?: {
+        amount?: number;
+        currency?: string;
+        formatted_amount?: string;
+        description?: string;
+        from?: string;
+        to?: string;
+        status?: string;
+        payment_id?: string;
+        [key: string]: any;
+    };
+    /** When true, the UI shows a confirm/cancel step before executing. */
+    requires_confirmation?: boolean;
+    confirmation_message?: string;
+    /** Multi-party approval chain for this action. */
+    approval?: {
+        required_approvers: Array<{
+            entity_id: string;
+            display_name?: string;
+            role?: string;
+        }>;
+        current_approvals: Array<{
+            entity_id: string;
+            display_name?: string;
+            approved_at?: string;
+        }>;
+        status: 'pending' | 'partially_approved' | 'approved' | 'rejected';
+        min_approvals?: number;
+    };
+}
+/** Identity of a message sender (human, agent, or system). */
+interface MessageSender {
+    entity_id: string;
+    display_name: string;
+    type?: 'human' | 'agent' | 'system';
+    role?: 'moderator' | 'participant' | 'observer';
+    avatar_color?: string;
+    /** Uploaded avatar image URL. Takes precedence when set. */
+    avatar_url?: string;
+    /** Pre-resolved glyph (emoji/icon char) from the host app's avatar
+     *  catalog. Rendered inside a circle when `avatar_url` is absent. */
+    avatar_glyph?: string;
+    /** Tailwind/CSS class for the glyph's background circle. Used when
+     *  `avatar_glyph` is set. */
+    avatar_bg_class?: string;
+}
+/** Parsed @-mention within a message. */
+interface Mention {
+    entity_id: string;
+    display_name: string;
+    start_index: number;
+    end_index: number;
+}
+/** Command entry for the / command palette. */
+interface TerminalCommand {
+    id: string;
+    label: string;
+    description: string;
+    category?: 'built-in' | 'custom';
+}
+/** Target for @-mention autocomplete (humans, agents, @all). */
+interface MentionTarget {
+    entity_id: string;
+    display_name: string;
+    type?: 'human' | 'agent' | 'special';
+    role?: string;
+    status?: 'active' | 'idle' | 'offline';
+}
+/** Audience envelope for directed messages. */
+interface MessageAudience {
+    type: 'all' | 'direct';
+    recipients: string[];
+}
+interface ReasoningSnapshot {
+    iteration?: number;
+    maxIterations?: number;
+    phase?: string;
+    agents?: {
+        id: string;
+        status: string;
+        display_name?: string;
+        role?: string;
+        focus?: string;
+    }[];
+    narrativeBlocks: string[];
+    agentThinking: Record<string, string>;
+    agentOutputs?: Record<string, {
+        role: string;
+        content: string;
+        confidence?: number;
+    }>;
+    agentRebuttals?: Record<string, {
+        role: string;
+        content: string;
+        agreements: string[];
+        disagreements: string[];
+    }>;
+    knowledgeGraph?: LegacyKGSnapshot;
+    genericKG?: GenericKGSnapshot;
+    elapsedMs?: number;
+    cancelled?: boolean;
+    /** Total turns recorded in this run (terminal informational). */
+    turn?: number;
+    /** Pipeline run id this snapshot was captured from. */
+    run_id?: string;
+}
+interface PipelineBuilderAction {
+    action: 'add_steps' | 'remove_step' | 'edit_step' | 'clear_all' | 'set_template_name' | 'set_pipeline_name';
+    steps?: PipelineDraftStep[];
+    index?: number;
+    label?: string;
+    config?: Record<string, any>;
+    name?: string;
+}
+interface PipelineDraft {
+    draft_id: string | null;
+    group_id: string;
+    name: string;
+    description?: string;
+    steps: PipelineDraftStep[];
+    explanation?: string;
+    status: 'draft' | 'preview' | 'submitted' | 'rejected';
+}
+interface PipelineDraftStep {
+    step_key: string;
+    name: string;
+    step_type: string;
+    step_config: Record<string, any>;
+    depends_on: string[];
+    assignee_type?: string;
+    assignee_id?: string;
+    input_bindings?: Record<string, any>;
+}
+interface TerminalSource {
+    id: string;
+    label: string;
+    type?: string;
+    typeColor?: string;
+    description?: string;
+}
+interface TerminalEntry {
+    id?: string;
+    type: 'system' | 'command' | 'info' | 'response' | 'error' | 'success';
+    content: string;
+    timestamp: Date;
+    suggestions?: PageSuggestion[];
+    suggested_actions?: AIAction[];
+    reasoning_snapshot?: ReasoningSnapshot;
+    pipeline_draft?: PipelineDraft;
+    /** Message sender for multi-party attribution. */
+    sender?: MessageSender;
+    /** Parsed @-mentions in this message. */
+    mentions?: Mention[];
+    /** KG id (kgf.knowledge_graphs.id) this message is bound to — when set,
+     *  renders a "View Knowledge Graph" button. Replaces the legacy
+     *  `reasoning_set_id`. */
+    kg_id?: string;
+    /** Pipeline run id (kgf.pipeline_runs.id) this message was generated from.
+     *  Used to subscribe to `/pipelines/:run_id/events` for delta updates. */
+    run_id?: string;
+    /** Source citations attached to this response. */
+    sources?: TerminalSource[];
+    /** Arbitrary data for custom rendering via renderEntryExtra. */
+    metadata?: Record<string, any>;
+}
+interface ApiEndpoint {
+    id: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    path: string;
+    description: string;
+    category: string;
+    params: ApiParameter[];
+    baseUrl: string;
+    isGraphQL?: boolean;
+}
+interface ApiParameter {
+    name: string;
+    type: string;
+    required: boolean;
+    description: string;
+    example: string;
+}
+interface TerminalCommandResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+    data?: any;
+}
+interface PageSuggestion {
+    id: string;
+    title: string;
+    description: string;
+    path: string;
+    keywords: string[];
+    icon: string;
+}
+interface TerminalConfig {
+    endpoints: ApiEndpoint[];
+    helpTopics?: HelpTopic[];
+    pageSuggestions?: PageSuggestion[];
+    apiBaseUrl?: string;
+    agentsApiUrl?: string;
+    /** Unified GraphQL endpoint for entity/wallet/asset queries in action cards. */
+    graphqlUrl?: string;
+    welcomeMessage?: string;
+    showWelcomeMessage?: boolean;
+    /** Custom commands shown in the / command palette alongside built-ins. */
+    customCommands?: TerminalCommand[];
+}
+interface HelpTopic {
+    name: string;
+    content: string;
+}
+interface GapOption {
+    id: string;
+    label: string;
+}
+interface GapQuestion {
+    question: string;
+    options: GapOption[];
+    allow_multiple: boolean;
+}
+interface TeamSetupAgent {
+    id: string;
+    display_name: string;
+    role: string;
+    expertise: string[];
+    focus?: string;
+}
+/** Lightweight KG projection used by `ReasoningSnapshot` to capture a
+ *  point-in-time view of the live graph. The richer `KGSnapshot` from
+ *  `kg/snapshot.rs` lives in `src/knowledge/types.ts` and is fetched
+ *  separately from `GET /kgs/:id`. */
+interface LegacyKGSnapshotNode {
+    id: string;
+    node_type: string;
+    label: string;
+    description: string;
+    confidence?: number;
+    source?: string;
+    iteration?: number;
+}
+interface LegacyKGSnapshotEdge {
+    id: string;
+    edge_type: string;
+    from: string;
+    to: string;
+    strength?: number;
+    label: string;
+}
+interface LegacyKGSnapshot {
+    nodes: LegacyKGSnapshotNode[];
+    edges: LegacyKGSnapshotEdge[];
+    node_count: number;
+    edge_count: number;
+    iteration: number;
+}
+type ClaimStatus = 'proposed' | 'supported' | 'challenged' | 'accepted' | 'rejected';
+interface Annotation {
+    id: string;
+    agent_id: string;
+    annotation_type: 'support' | 'question' | 'challenge' | 'claim' | 'disagreement';
+    content: string;
+    resolved: boolean;
+    resolution: string | null;
+    source?: string;
+}
+interface GenericSnapshotNode {
+    id: string;
+    node_type: string;
+    label: string;
+    description: string;
+    confidence: number;
+    /** @deprecated Use claim_status instead */
+    phase?: 'problem' | 'solution' | 'simple';
+    claim_status?: ClaimStatus;
+    settled: boolean;
+    annotation_count: number;
+    unresolved_count: number;
+    created_by: string | null;
+    annotations: Annotation[];
+}
+interface GenericSnapshotEdge {
+    id: string;
+    from: string;
+    to: string;
+    relationship: string;
+    description: string;
+    confidence: number;
+    settled: boolean;
+    claim_status?: ClaimStatus;
+    /** Agent that proposed this claim. */
+    created_by?: string;
+    triple: string;
+    annotations: Annotation[];
+}
+interface GenericKGSnapshot {
+    node_count: number;
+    edge_count: number;
+    settled_count: number;
+    unsettled_count: number;
+    nodes: GenericSnapshotNode[];
+    edges: GenericSnapshotEdge[];
+}
+/** Unified progress event consumed by the reasoning UI. The discriminator
+ *  union covers both the legacy PascalCase variants and the snake_case
+ *  `TransformProgress` variants from `/pipelines/:run_id/events`. */
+interface ReasoningProgressEvent {
+    type: 'Connected' | 'IterationStart' | 'PhaseStart' | 'AgentStatus' | 'CoherenceAssessment' | 'StepUpdate' | 'SolutionCoherence' | 'Convergence' | 'Synthesizing' | 'NarrativeText' | 'WaitingForInput' | 'AgentThinking' | 'AgentComplete' | 'TeamSetup' | 'KnowledgeGraphUpdate' | 'GenericKGUpdate' | 'RebuttalStart' | 'AgentRebuttal' | 'RevisedProcessStart' | 'TurnStart' | 'TurnComplete' | 'ConvergenceUpdate' | 'PhaseAdvanced' | 'PhaseBacktracked' | 'VerificationRan' | 'ProxyMutationsApplied' | 'SystemResponse' | 'SchemaTypeAdded' | 'ClaimStatusChanged' | 'SchemaSeeded' | 'SchemaReconciled' | 'pipeline_started' | 'pipeline_step_started' | 'pipeline_step_complete' | 'pipeline_checkpoint' | 'pipeline_paused' | 'pipeline_complete' | 'pipeline_failed' | 'transform_started' | 'transform_complete' | 'turn_started' | 'turn_complete' | 'input_processed' | 'agent_invoked' | 'agent_inner_round_complete' | 'agent_done' | 'node_added' | 'edge_added' | 'annotated' | 'annotation_resolved' | 'dedup_collapsed' | 'edge_dropped' | 'vocabulary_evolved' | 'schema_verified' | 'claim_status_changed' | 'convergence_update' | 'persisted' | 'kg_updated' | 'read_tool_called' | 'read_tool_result' | 'side_effect_executed' | 'waiting_for_input' | 'human_input_received' | 'transform_extension';
+    iteration?: number;
+    max_iterations?: number;
+    phase?: string;
+    description?: string;
+    agents?: {
+        id: string;
+        status: string;
+        display_name?: string;
+        role?: string;
+        focus?: string;
+    }[];
+    coverage?: number;
+    harmony?: number;
+    grounding?: number;
+    overall?: number;
+    is_coherent?: boolean;
+    step?: string;
+    detail?: string;
+    requirements_met?: boolean;
+    score?: number;
+    target?: number;
+    text?: string;
+    prompt?: string;
+    context?: string;
+    agent_id?: string;
+    snippet?: string;
+    role?: string;
+    content?: string;
+    confidence?: number;
+    questions?: GapQuestion[];
+    team_agents?: TeamSetupAgent[];
+    snapshot?: LegacyKGSnapshot;
+    generic_snapshot?: GenericKGSnapshot;
+    agreements?: string[];
+    disagreements?: string[];
+    turn?: number;
+    max_turns?: number;
+    active_agents?: string[];
+    from?: string;
+    to?: string;
+    mode?: string;
+    ontological?: boolean;
+    epistemic?: boolean;
+    converged?: boolean;
+    errors?: number;
+    warnings?: number;
+    entity_id?: string;
+    node_count?: number;
+    edge_count?: number;
+    type_name?: string;
+    added_by?: string;
+    edge_id?: string;
+    old_status?: string;
+    new_status?: string;
+    node_type_count?: number;
+    edge_type_count?: number;
+    has_constraints?: boolean;
+    novel_types_merged?: number;
+    novel_types_kept?: number;
+    needs_repass?: boolean;
+    /** Pipeline run id (kgf.pipeline_runs.id). */
+    run_id?: string;
+    /** KG id (kgf.knowledge_graphs.id) — both for tagging and for `pipeline_complete`. */
+    kg_id?: string;
+    /** Pipeline kind: file_extraction | reasoning | extract_then_reason. */
+    kind?: string;
+    total_steps?: number;
+    step_index?: number;
+    step_kind?: string;
+    name?: string;
+    /** For `pipeline_checkpoint`. */
+    checkpoint_id?: string;
+    reason?: string;
+    payload?: any;
+    requires_user_action?: boolean;
+    total_inputs?: number;
+    total_nodes?: number;
+    total_edges?: number;
+    index?: number;
+    total?: number;
+    label?: string;
+    round?: number;
+    mutations?: number;
+    reads?: number;
+    key?: string;
+    node_type?: string;
+    edge_type?: string;
+    layer?: string;
+    target_key?: string;
+    annotation_type?: string;
+    annotation_id?: string;
+    proposed_key?: string;
+    matched_key?: string;
+    action?: string;
+    added_node_types?: number;
+    added_edge_types?: number;
+    novel_node_types?: any[];
+    novel_edge_types?: any[];
+    nodes?: number;
+    edges?: number;
+    chunk_links?: number;
+    tool?: string;
+    query?: string;
+    result_summary?: string;
+    pending_guidance?: number;
+    pending_proxy_mutations?: number;
+    /** For human_input_received: kind of input (proceed/done/cancel/guidance/agent_done/proxy_mutation/rewind). */
+    input_kind?: string;
+    input_label?: string;
+    /** @deprecated alias of `kg_id`, kept for transitional compatibility. */
+    reasoning_set_id?: string;
+    /** @deprecated alias of `thread_id`, kept for transitional compatibility. */
+    reasoning_thread_id?: string;
+    thread_id?: string;
+}
+interface StreamChunk {
+    chunk?: string;
+    thread_id?: string;
+    /** KG id (kgf.knowledge_graphs.id) this chunk belongs to. */
+    kg_id?: string;
+    /** Pipeline run id (kgf.pipeline_runs.id). */
+    run_id?: string;
+    /** @deprecated alias of `kg_id`, kept for transitional compatibility. */
+    reasoning_set_id?: string;
+    /** @deprecated alias of `thread_id`, kept for transitional compatibility. */
+    reasoning_thread_id?: string;
+    is_final?: boolean;
+    suggested_actions?: any[];
+    page_suggestions?: PageSuggestion[];
+    progress?: ReasoningProgressEvent;
+    processing_mode?: string;
+    collaboration?: {
+        session_id?: string;
+        input_mode?: 'open_floor' | 'moderated' | 'round_robin';
+        participants?: Array<{
+            entity_id: string;
+            display_name?: string;
+            role?: 'moderator' | 'participant' | 'observer';
+            status?: 'active' | 'idle' | 'offline';
+        }>;
+    };
+    knowledge?: {
+        nodes_count?: number;
+        edges_count?: number;
+        top_nodes?: Array<{
+            id: string;
+            type?: string;
+            description?: string;
+        }>;
+        /** Node ids that the response actually grounded on. Used by the chat
+         *  panel to highlight cited nodes in the surrounding KG view. */
+        nodes_used?: string[];
+    };
+    /** Top-level shortcut for `knowledge.nodes_used`, supported by some backends. */
+    nodes_used?: string[];
+    pipeline_draft?: PipelineDraft;
+    pipeline_actions?: PipelineBuilderAction[];
+    /** Sender identity for attributed messages in multi-party sessions. */
+    sender?: MessageSender;
+    /** Source citations for RAG-grounded responses. */
+    sources?: TerminalSource[];
+    /** Real-time approval update for a previously suggested action. */
+    approval_update?: {
+        action_id: string;
+        entity_id: string;
+        display_name?: string;
+        decision: 'approved' | 'rejected';
+        timestamp: string;
+    };
+}
+interface StreamHandler {
+    onChunk: (chunk: StreamChunk) => void;
+    onComplete: () => void;
+    onError: (error: string) => void;
+}
+interface WorkingGroupContext {
+    workingGroupId: string;
+    pageKey: string;
+    pageTitle?: string;
+}
+interface KGScope {
+    /** KG id (kgf.knowledge_graphs.id). */
+    kgId: string;
+    label: string;
+    nodeCount?: number;
+}
+interface FileUploadResult {
+    success: boolean;
+    message?: string;
+    documentsIngested?: number;
+    failedFiles?: string[];
+    data?: any;
+    /** Pipeline runs spawned by `POST /pipelines/ingest-document`, one per
+     *  uploaded file. The terminal subscribes to `/pipelines/:run_id/events`
+     *  for each one to render upload + extraction progress. */
+    pipelineRuns?: Array<{
+        run_id: string;
+        kg_id: string;
+        /** Original file name, for display. */
+        title?: string;
+    }>;
+}
+interface ListedRagFile {
+    id: string;
+    title: string;
+    document_type?: string;
+    status?: string;
+    summary?: string;
+    url?: string;
+}
+interface ListRagFilesResult {
+    success: boolean;
+    message?: string;
+    files?: ListedRagFile[];
+}
+interface RagFileActionResult {
+    success: boolean;
+    message?: string;
+}
+
+interface TerminalPlugin {
+    name: string;
+    handleCommand?: (command: string, endpoint?: ApiEndpoint, params?: Record<string, string>) => Promise<TerminalCommandResult | null>;
+    handleStream?: (command: string, handlers: StreamHandlers) => Promise<void>;
+    onInit?: () => void;
+    onDestroy?: () => void;
+}
+interface StreamHandlers {
+    onChunk: (chunk: StreamChunk) => void;
+    onComplete: () => void;
+    onError: (error: string) => void;
+}
+interface PluginContext {
+    config: any;
+    apiService?: any;
+}
+
+/** Live reasoning progress state managed via reduceProgress. */
+interface ProgressState {
+    iteration?: number;
+    maxIterations?: number;
+    phase?: string;
+    phaseDescription?: string;
+    agents?: {
+        id: string;
+        status: string;
+        display_name?: string;
+        role?: string;
+        focus?: string;
+    }[];
+    coherence?: {
+        coverage: number;
+        harmony: number;
+        grounding: number;
+        overall: number;
+        isCoherent: boolean;
+    };
+    currentStep?: string;
+    stepDetail?: string;
+    solutionCoherence?: {
+        overall: number;
+        requirementsMet: boolean;
+    };
+    convergence?: {
+        score: number;
+        target: number;
+    };
+    synthesizing: boolean;
+    narrativeBlocks: string[];
+    waitingForInput: boolean;
+    inputPrompt?: string;
+    inputContext?: string;
+    inputQuestions?: GapQuestion[];
+    threadId?: string;
+    agentThinking: Record<string, string>;
+    agentOutputs: Record<string, {
+        role: string;
+        content: string;
+        confidence?: number;
+    }>;
+    teamSetup?: TeamSetupAgent[];
+    knowledgeGraph?: LegacyKGSnapshot;
+    genericKG?: GenericKGSnapshot;
+    connectionLost?: boolean;
+    startedAtMs?: number;
+    lastUpdateAtMs?: number;
+    rebuttalPhase?: 'rebuttal' | 'revised' | null;
+    turn?: number;
+    maxTurns?: number;
+    activeAgents?: string[];
+    pipelinePhase?: string;
+    ontologicalConverged?: boolean;
+    epistemicConverged?: boolean;
+    converged?: boolean;
+    reasoningGoal?: string;
+    /** Ordered list of pipeline phases visited */
+    pipelinePhases?: string[];
+    agentRebuttals?: Record<string, {
+        role: string;
+        content: string;
+        agreements: string[];
+        disagreements: string[];
+    }>;
+}
+/** Capture a snapshot of current reasoning state for history. */
+declare function captureReasoningSnapshot(state: ProgressState, cancelled?: boolean): ReasoningSnapshot;
+/** Pure reducer: apply a ReasoningProgressEvent to ProgressState. */
+declare function reduceProgress(state: ProgressState, event: ReasoningProgressEvent): ProgressState;
+
+/** A registered custom widget that renders per-entry when its condition is met. */
+interface TerminalWidget {
+    /** Unique key for React reconciliation. */
+    name: string;
+    /** Return true to render this widget for the given entry. */
+    match: (entry: TerminalEntry) => boolean;
+    /** The widget component. Receives the entry and its index. */
+    render: (props: {
+        entry: TerminalEntry;
+        index: number;
+    }) => React.ReactNode;
+    /** Where to render relative to built-in widgets. Default: 'after'. */
+    position?: 'before' | 'after' | 'replace';
+}
+/** Slot-based injection points for persistent content around the terminal. */
+interface TerminalSlots {
+    /** Rendered inside the header bar, after the brain icon and before the settings button. */
+    headerExtra?: React.ReactNode;
+    /** Rendered at the top of the scrollable body, before any entries. */
+    beforeEntries?: React.ReactNode;
+    /** Rendered at the bottom of the scrollable body, after all entries. */
+    afterEntries?: React.ReactNode;
+    /** Rendered inside the input bar area, between the toolbar hints and the action buttons. */
+    inputBarExtra?: React.ReactNode;
+    /** When provided, **replaces** the default Auto/Reason mode selector in the
+     *  input bar toolbar. Consumers can inject any button (e.g. Direct/Coach in
+     *  the Agent Studio) while keeping the same toolbar position and styling. */
+    modeSelector?: React.ReactNode;
+}
+/** Props shared by both StandardTerminal and ChatTerminal. */
+interface BaseTerminalProps {
+    /** Custom theme overrides — merged with defaultTheme. */
+    theme?: Partial<TerminalTheme>;
+    config: TerminalConfig;
+    className?: string;
+    style?: React.CSSProperties;
+    showHeader?: boolean;
+    showWelcomeMessage?: boolean;
+    initialHistory?: TerminalEntry[];
+    onHistoryChange?: (history: TerminalEntry[]) => void;
+    onStreamRequest?: (command: string, handlers: {
+        onChunk: (chunk: StreamChunk) => void;
+        onComplete: () => void;
+        onError: (error: string) => void;
+    }, options?: {
+        reasoningMode?: ReasoningMode | null;
+    }) => Promise<void>;
+    /** Current reply-path mode: 'auto' (intent classifier decides) or 'quick'
+     *  (skip classification, fast direct LLM). Controlled — when omitted, the
+     *  terminal manages its own internal state. */
+    reasoningMode?: ReasoningMode | null;
+    onReasoningModeChange?: (mode: ReasoningMode | null) => void;
+    onResolveWorkingGroup?: () => Promise<WorkingGroupContext | null>;
+    workingGroupContext?: WorkingGroupContext | null;
+    onRagFileUpload?: (files: File[], context?: WorkingGroupContext | null) => Promise<FileUploadResult>;
+    onListRagFiles?: (context?: WorkingGroupContext | null) => Promise<ListRagFilesResult>;
+    onDeleteRagFile?: (documentId: string, context?: WorkingGroupContext | null) => Promise<RagFileActionResult>;
+    onDownloadRagFile?: (documentId: string, title?: string, context?: WorkingGroupContext | null) => Promise<RagFileActionResult>;
+    onPipelineDraftEdit?: (draft: PipelineDraft) => Promise<void>;
+    onPipelineDraftReject?: (draft: PipelineDraft) => Promise<void>;
+    /** Persist a free-form prose note via the host's notebook service.
+     *  Wired by both the `/note` slash command (workspace scope) and
+     *  the `/personal` slash command (force personal scope from inside
+     *  a team workspace). The `scope` arg lets the host route to the
+     *  right notebook KG; absent → workspace (the legacy default).
+     *  Returns a short message the terminal echoes as a success/error
+     *  line. */
+    onSubmitNote?: (prose: string, scope?: 'workspace' | 'personal') => Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    /** Resolve a partial `@<query>` typed inside a slash command (e.g.
+     *  `/note @wi`) to substrate entities. The terminal renders the
+     *  results as a picker popover; selecting one replaces the query
+     *  with `@<display_name> ` and notifies via `onMentionPicked`.
+     *  `command` is the active slash-command name (e.g. `'note'` or
+     *  `'personal'`) so hosts can scope candidates per-command. */
+    onMentionResolve?: (query: string, command?: string) => Promise<Array<{
+        entity_id: string;
+        display_name: string;
+        concept_type?: string;
+    }>>;
+    /** Notified when the user picks an entity from the slash-command
+     *  mention picker. Hosts use this to remember the explicit pick so
+     *  `onSubmitNote` can use the precise frame_id rather than relying
+     *  on a label re-lookup at submit time. */
+    onMentionPicked?: (entity: {
+        entity_id: string;
+        display_name: string;
+    }) => void;
+    onPageNavigation?: (page: PageSuggestion) => void;
+    availableKGs?: KGScope[];
+    activeKGScope?: KGScope | null;
+    onKGScopeChange?: (scope: KGScope | null) => void;
+    onViewKnowledgeGraph?: (snapshot: GenericKGSnapshot | LegacyKGSnapshot) => void;
+    onLiveKGUpdate?: (snapshot: GenericKGSnapshot) => void;
+    /** Called when the active KG id changes. Replaces `onReasoningSetIdChange`. */
+    onKgIdChange?: (id: string | null) => void;
+    /** Called when the active pipeline run id changes (used by hosts that
+     *  want to mirror the run id into URL state or open a debug pane). */
+    onRunIdChange?: (id: string | null) => void;
+    /** Called when the active conversational thread id changes. Replaces
+     *  `onReasoningThreadIdChange`. */
+    onThreadIdChange?: (id: string | null) => void;
+    sourceKGNodes?: GenericSnapshotNode[];
+    renderEntryExtra?: (entry: TerminalEntry, index: number) => React.ReactNode;
+    /** Full override for entry rendering. Return `null` to use default rendering. */
+    renderEntry?: (entry: TerminalEntry, index: number, defaultRender: () => React.ReactNode) => React.ReactNode;
+    /** Custom widgets that render per-entry based on a match condition. */
+    widgets?: TerminalWidget[];
+    /** Slot-based injection points for persistent content around the terminal. */
+    slots?: TerminalSlots;
+    onSourcesActivate?: (sources: TerminalSource[], entry: TerminalEntry) => void;
+    /** Poll for new messages (e.g. agent push messages). Called every pollIntervalMs. */
+    onPollMessages?: (lastMessageId?: string) => Promise<TerminalEntry[]>;
+    /** Polling interval in ms. Default 3000. */
+    pollIntervalMs?: number;
+    historyRef?: React.MutableRefObject<{
+        setHistory: React.Dispatch<React.SetStateAction<TerminalEntry[]>>;
+        setIsExecuting?: React.Dispatch<React.SetStateAction<boolean>>;
+    } | null>;
+    reasoningRef?: React.MutableRefObject<{
+        progressState: ProgressState | null;
+        submitInput: (message: string) => void;
+        cancelReasoning: () => void;
+    } | null>;
+    /** Called when the pipeline phase changes (e.g. "vocab_discovery" -> "extraction"). */
+    onReasoningPhaseChange?: (phase: string | null) => void;
+    /** Called with accumulated activity events for the KG ticker */
+    onActivityEventsChange?: (events: any[]) => void;
+    windowWidth?: number;
+}
+/** StandardTerminal — developer console with API endpoints and commands. */
+interface StandardTerminalProps extends BaseTerminalProps {
+    onCommandExecute?: (command: string, endpoint?: ApiEndpoint, params?: Record<string, string>) => Promise<TerminalCommandResult>;
+    authToken?: string;
+    onAuthTokenChange?: (token: string) => void;
+}
+/** ChatTerminal — multi-party chat with mentions, presence, and polling. */
+interface ChatTerminalProps extends BaseTerminalProps {
+    currentUser?: MessageSender;
+    onSendMessage?: (content: string, mentions?: Mention[], audience?: MessageAudience) => Promise<TerminalEntry>;
+    onLoadMessages?: () => Promise<TerminalEntry[]>;
+    mentionTargets?: MentionTarget[];
+    typingUsers?: Array<{
+        entityId: string;
+        displayName: string;
+    }>;
+    onTyping?: () => void;
+}
+
+declare function StandardTerminal({ theme: themeOverrides, config, onCommandExecute, onPageNavigation, authToken, onAuthTokenChange, className, style, showHeader, showWelcomeMessage, initialHistory, onHistoryChange, onStreamRequest, onResolveWorkingGroup, onRagFileUpload, onListRagFiles, onDeleteRagFile, onDownloadRagFile, workingGroupContext: workingGroupContextProp, onPipelineDraftEdit, onPipelineDraftReject, onSubmitNote, onMentionResolve, onMentionPicked, availableKGs, activeKGScope, onKGScopeChange, onViewKnowledgeGraph, onLiveKGUpdate, onKgIdChange, onRunIdChange, onThreadIdChange, onReasoningPhaseChange, reasoningRef, reasoningMode: reasoningModeProp, onReasoningModeChange: onReasoningModeChangeProp, sourceKGNodes, renderEntryExtra, renderEntry, widgets, slots, onSourcesActivate, onPollMessages, pollIntervalMs, historyRef, }: StandardTerminalProps): react_jsx_runtime.JSX.Element;
+
+declare function ChatTerminal({ theme: themeOverrides, config, className, style, showHeader, showWelcomeMessage, initialHistory, onHistoryChange, onStreamRequest, onResolveWorkingGroup, onRagFileUpload, onListRagFiles, onDeleteRagFile, onDownloadRagFile, workingGroupContext: workingGroupContextProp, onPipelineDraftEdit, onPipelineDraftReject, onPageNavigation, availableKGs, activeKGScope, onKGScopeChange, onViewKnowledgeGraph, onLiveKGUpdate, onKgIdChange, onRunIdChange, onThreadIdChange, onReasoningPhaseChange, onActivityEventsChange, reasoningRef, reasoningMode: reasoningModeProp, onReasoningModeChange: onReasoningModeChangeProp, sourceKGNodes, renderEntryExtra, renderEntry, widgets, slots, onSourcesActivate, historyRef, currentUser, onSendMessage, onPollMessages, mentionTargets, pollIntervalMs, typingUsers, onTyping, onSubmitNote, onMentionResolve, onMentionPicked, }: ChatTerminalProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * CoreTerminal — routing facade for backward compatibility.
+ * Routes to ChatTerminal when chat props are present, StandardTerminal otherwise.
+ * Prefer importing StandardTerminal or ChatTerminal directly.
+ */
+type CoreTerminalProps = StandardTerminalProps & ChatTerminalProps;
+declare function CoreTerminal(props: CoreTerminalProps): react_jsx_runtime.JSX.Element;
+
+interface ExpandableTerminalProps extends CoreTerminalProps {
+    guidanceMessage?: string;
+    onGuidanceRequest?: () => Promise<string>;
+}
+declare function ExpandableTerminal({ guidanceMessage, onGuidanceRequest, className, windowWidth, initialHistory, theme: themeOverrides, ...terminalProps }: ExpandableTerminalProps): react_jsx_runtime.JSX.Element;
+
+interface InlineTerminalProps {
+    contextName?: string;
+    placeholder?: string;
+    onStreamRequest?: (command: string, handlers: {
+        onChunk: (chunk: StreamChunk) => void;
+        onComplete: () => void;
+        onError: (error: string) => void;
+    }) => Promise<void>;
+    isOnline?: boolean;
+    className?: string;
+    autoFocus?: boolean;
+}
+declare function InlineTerminal({ contextName, placeholder, onStreamRequest, isOnline, className, autoFocus, }: InlineTerminalProps): react_jsx_runtime.JSX.Element;
+
+declare function ReasoningHistoryCard({ snapshot, defaultExpanded, }: {
+    snapshot: ReasoningSnapshot;
+    defaultExpanded?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Deterministic agent visual identity — one component and one set of
+ * helpers, used everywhere an agent is rendered.
+ *
+ * Same agent id (or display name) always renders the same face and the
+ * same accent color — the seed is canonicalised inside this module so
+ * all three forms the caller may have (`agent:buddy` / `Buddy` / `buddy`)
+ * collapse to the same hash, which in turn picks the same palette entry
+ * for both the avatar background and the accent color used for labels,
+ * pill borders, and badges.
+ *
+ * Public API:
+ *   - `<AgentAvatar name={seed} size={...} />` — the rendered character
+ *   - `getAgentColor(name)` — stable accent color for this agent
+ *   - `agentSeed(...candidates)` — pick the first non-empty seed candidate
+ *   - `AGENT_PALETTE` — the six-entry palette (exported for consumers
+ *     that need to reason about the colors directly)
+ */
+
+/**
+ * One palette for the whole system. Avatar halo and accent-text color
+ * pull from the same six colors via the same hash, so an agent's name
+ * label and their avatar background always coordinate.
+ *
+ * Stored without the `#` prefix because DiceBear expects hex-less
+ * strings; `getAgentColor` prepends `#` for CSS use.
+ */
+declare const AGENT_PALETTE: readonly ["a78bfa", "f472b6", "60a5fa", "34d399", "fbbf24", "fb7185"];
+/**
+ * Stable accent color for an agent — used for colored name labels,
+ * mention-pill borders, and edge-label text next to an avatar.
+ *
+ * Always canonicalises the input, so `getAgentColor('Buddy')` and
+ * `getAgentColor('agent:buddy')` return the same color.
+ */
+declare function getAgentColor(name: string): string;
+/**
+ * Pick the first non-empty seed candidate. Lets call sites write
+ * `agentSeed(agent.id, agent.display_name)` instead of repeating the
+ * `a || b` fallback pattern everywhere.
+ */
+declare function agentSeed(...candidates: Array<string | null | undefined>): string;
+type AgentAvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+interface AgentAvatarProps {
+    /** Stable seed — prefer the agent's `id`, fall back to `display_name`. */
+    name: string;
+    /** Named preset or pixel number. */
+    size?: AgentAvatarSize;
+    className?: string;
+}
+declare const AgentAvatar: React.FC<AgentAvatarProps>;
+
+interface TerminalInputBarProps {
+    inputRef: React.RefObject<HTMLTextAreaElement>;
+    fileInputRef: React.RefObject<HTMLInputElement>;
+    currentCommand: string;
+    isExecuting: boolean;
+    placeholder?: string;
+    onInputChange: (value: string) => void;
+    onKeyDown: (e: React.KeyboardEvent) => void;
+    onSubmit: () => void;
+    onTyping?: () => void;
+    onUploadFiles: (files: File[]) => void;
+    onListFilesCommand: () => void;
+    availableKGs?: KGScope[];
+    activeKGScope?: KGScope | null;
+    onKGScopeChange?: (scope: KGScope | null) => void;
+    /** Reply-path mode toggle: 'auto' (intent classifier decides) or 'quick' (skip reasoning). */
+    reasoningMode?: ReasoningMode | null;
+    onReasoningModeChange?: (mode: ReasoningMode | null) => void;
+    /** Known mention names for inline highlighting */
+    knownMentionNames?: string[];
+    /** Reports the caret position in the FULL command (not the
+     *  textarea-local position, which is relative to the tail when
+     *  pills consume the prefix). Slash-mention picker uses this. */
+    onCaretChange?: (absoluteCaret: number) => void;
+    showUploadButton?: boolean;
+    showFilesButton?: boolean;
+    commandPaletteItems: TerminalCommand[];
+    selectedPaletteItem: number;
+    onSelectPaletteItem: (id: string) => void;
+    inputBarExtra?: React.ReactNode;
+    /** When provided, replaces the default Auto/Reason selector in the toolbar. */
+    modeSelector?: React.ReactNode;
+    /** Keeps toolbar affordances icon-sized even in a wide container. */
+    compactToolbar?: boolean;
+    /** Accessible label for the submit affordance. */
+    submitTitle?: string;
+}
+declare function TerminalInputBar({ inputRef, fileInputRef, currentCommand, isExecuting, placeholder, onInputChange, onKeyDown, onSubmit, onTyping, onUploadFiles, onListFilesCommand, availableKGs, activeKGScope, onKGScopeChange, reasoningMode, onReasoningModeChange, knownMentionNames, onCaretChange, showUploadButton, showFilesButton, commandPaletteItems, selectedPaletteItem, onSelectPaletteItem, inputBarExtra, modeSelector, compactToolbar, submitTitle, }: TerminalInputBarProps): react_jsx_runtime.JSX.Element;
+
+interface SlashMentionCandidate {
+    entity_id: string;
+    display_name: string;
+    concept_type?: string;
+}
+interface UseSlashMentionPickerArgs {
+    currentCommand: string;
+    caretIndex: number;
+    /** Resolver for `@<query>` matches. Receives the typed prefix and,
+     *  when active inside a slash-command shape, the command name (e.g.
+     *  `'note'`, `'personal'`) so the host can scope candidates per
+     *  command (team-scoped vs personal-scoped). */
+    onMentionResolve?: (query: string, command?: string) => Promise<SlashMentionCandidate[]>;
+    /** Slash commands eligible for mention resolution. Default:
+     *  `['note', 'personal']`. Ignored when `requireSlashCommand` is
+     *  `false`. */
+    enabledCommands?: string[];
+    /** When `false`, the picker fires on any `@<query>` at the caret —
+     *  no slash-command prefix required. Used by surfaces that edit
+     *  prose directly (e.g. the notes editor) instead of typing a
+     *  slash command. Default: `true`. */
+    requireSlashCommand?: boolean;
+}
+/**
+ * Inline `@<query>` picker for slash-command input. Watches the
+ * caret position; when the input starts with an enabled slash command
+ * and the caret sits inside an unbroken `@…` token, it debounces a
+ * call to `onMentionResolve(query)` and exposes the candidates.
+ *
+ * The terminal renders the dropdown and calls `complete(candidate)`
+ * on Enter/Tab; this hook returns the new command string with the
+ * `@<query>` token replaced by `@<display_name> ` plus the offset to
+ * place the caret.
+ */
+declare function useSlashMentionPicker({ currentCommand, caretIndex, onMentionResolve, enabledCommands, requireSlashCommand, }: UseSlashMentionPickerArgs): {
+    query: string;
+    candidates: SlashMentionCandidate[];
+    selectedIndex: number;
+    navigateUp: () => void;
+    navigateDown: () => void;
+    cancel: () => void;
+    complete: (candidate: SlashMentionCandidate) => {
+        next: string;
+        caret: number;
+    } | null;
+    isOpen: boolean;
+};
+
+interface Props {
+    candidates: SlashMentionCandidate[];
+    selectedIndex: number;
+    onPick: (c: SlashMentionCandidate) => void;
+}
+declare function SlashMentionPicker({ candidates, selectedIndex, onPick }: Props): react_jsx_runtime.JSX.Element;
+
+interface ParsedCommand {
+    endpoint: ApiEndpoint;
+    args: Record<string, string>;
+}
+declare function parseTerminalCommand(cmd: string, endpoints: ApiEndpoint[]): ParsedCommand | null;
+declare function buildTerminalCommand(endpoint: ApiEndpoint, values: Record<string, string>): string;
+declare function isNaturalLanguage(cmd: string, endpoints: ApiEndpoint[]): boolean;
+
+declare function getBuiltInCommands(): TerminalCommand[];
+declare function filterCommands(query: string, builtIn: TerminalCommand[], custom?: TerminalCommand[]): TerminalCommand[];
+
+/**
+ * Shared stream-line buffering logic used by both sseHandler and streamingHandler.
+ * Eliminates duplicated buffer-split-parse loops.
+ */
+declare function processStreamLines(buffer: string, onJsonLine: (parsed: any) => void): string;
+
+/**
+ * Handles generic streaming JSON-line responses (non-SSE).
+ */
+declare function handleStreamingResponse(url: string, requestBody: any, onChunk: (chunk: StreamChunk) => void, onComplete: () => void, onError: (error: string) => void): Promise<void>;
+
+/**
+ * Handles Server-Sent Events (SSE) streaming responses.
+ *
+ * Pass `options.signal` to make the stream cancellable. When the signal aborts,
+ * the in-flight fetch + reader unwinds and the function returns silently —
+ * deliberate aborts are NOT surfaced as errors via onError.
+ *
+ * Pass `options.onGone` to handle 410 Gone specifically — used by the
+ * pipeline-events endpoint when a run is persisted but inactive in memory.
+ * If omitted, 410 falls through to onError like any other non-OK status.
+ */
+declare const handleSSEStream: (url: string, body: any, onChunk: (chunk: any) => void, onComplete: () => void, onError: (error: string) => void, options?: {
+    method?: string;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    onGone?: (reason: string) => void;
+}) => Promise<void>;
+
+/**
+ * Shared asset display formatting utilities.
+ * Eliminates 5+ copy-pasted formatting blocks across action card variants.
+ */
+/** Format a token asset ID like "aud-token-asset" to "Aud Token" */
+declare function formatTokenAssetId(assetId: string): string;
+/** Resolve a human-readable asset name from metadata fields. */
+declare function formatAssetDisplay(metadata: Record<string, any>, fallbackCurrency?: string): string;
+/**
+ * Resolve a display name from a payment leg object (initiator / counterparty).
+ * Handles asset_name > asset_id > denomination fallback chain.
+ */
+declare function resolvePaymentAssetDisplay(payment: Record<string, any>): string;
+/**
+ * Format a potentially-scaled payment amount to a human-readable string.
+ * Handles BigInt-scaled token amounts (e.g. 18-decimal ERC-20 tokens).
+ */
+declare function formatPaymentAmount(amount: string): string;
+
+/**
+ * Render a markdown-like text block into styled React elements.
+ * Eliminates duplicate line-parsing logic in ReasoningProgressIndicator
+ * and ReasoningHistoryCard.
+ */
+declare function renderMarkdownBlock(block: string, options?: {
+    headingClass?: string;
+    subheadingClass?: string;
+    textClass?: string;
+    listClass?: string;
+    boldClass?: string;
+}): React.ReactNode[];
+
+/**
+ * Shared avatar utilities for consistent rendering across
+ * AttributedMessage, MentionDropdown, PresenceBar, and ApprovalTracker.
+ */
+/** Deterministic color from an entity ID string. */
+declare function avatarColor(entityId: string): string;
+/** Extract up to 2 initials from a display name. */
+declare function initials(name: string): string;
+
+/**
+ * Extract source citations by matching KG node labels against response text.
+ * Tries full label, core label (before parens), parenthetical text, and
+ * reversed "X (Y)" → "Y (X)" patterns to handle varied AI phrasing.
+ */
+declare function extractKGSources(text: string, kgNodes: GenericSnapshotNode[]): TerminalSource[];
+
+/** Window event channel name for pipeline progress events.
+ *  Used by every panel/canvas/indicator that needs to react to backend
+ *  TransformProgress events (TeamSetup, PhaseAdvanced, SchemaSeeded, etc.). */
+declare const PROGRESS_EVENT_NAME = "yf-progress-event";
+/** Sentinel KG id meaning "the live, ad-hoc session" — i.e. the upstream
+ *  pipeline run hasn't reported a target KG id yet, but the panel still
+ *  wants to scope progress events to the active live session. */
+declare const LIVE_KG_ID = "__live__";
+/** True iff `id` identifies a *fixed, persisted* KG — i.e. not empty, and
+ *  not the live-session sentinel. Used to decide whether a panel has a
+ *  stable identity it can rely on (skip adoption, open SSE keepalive)
+ *  vs. a placeholder that should still adopt ids surfaced from chunks. */
+declare function isFixedKgId(id: string | null | undefined): id is string;
+/** "Approve current phase and advance to the next." Used by the team and
+ *  schema review steps when the user clicks the primary continue button. */
+declare const ADVANCE_PHASE_SIGNAL = "looks good";
+/** "Synthesis is complete." The synthesis-review step uses this instead of
+ *  ADVANCE_PHASE_SIGNAL because the executor's prompt distinguishes them. */
+declare const SYNTHESIS_DONE_SIGNAL = "done";
+/** Shape of the detail payload on a yf-progress-event window event.
+ *  This is intentionally permissive — different backend events carry
+ *  different fields and we only care about a small set here. */
+interface ProgressEventDetail {
+    type?: string;
+    /** KG id (kgf.knowledge_graphs.id) the event applies to. */
+    kg_id?: string;
+    /** Pipeline run id (kgf.pipeline_runs.id) the event was emitted from. */
+    run_id?: string;
+    /** @deprecated alias of `kg_id`, kept so old payloads still flow through scoped listeners. */
+    reasoning_set_id?: string;
+    [key: string]: any;
+}
+/** Permissive shape for any object that might carry a KG id. */
+type KgIdSource = {
+    kg_id?: string | null;
+    reasoning_set_id?: string | null;
+} | null | undefined;
+/** Walk a precedence list of `{kg_id, reasoning_set_id}`-bearing objects
+ *  and return the first non-empty id found. The single source of truth
+ *  for resolving the legacy `reasoning_set_id` fallback — when that
+ *  field finally goes away on the wire, this function is the only place
+ *  to delete the branch. */
+declare function extractKgId(...sources: KgIdSource[]): string | undefined;
+interface DispatchOptions {
+    /** The KG id to fall back to if the chunk/progress payload doesn't
+     *  already carry one. Typically the panel/hook's own kg id. */
+    fallbackKgId?: string | null;
+    /** Optional outer chunk that may carry kg_id at the top level (some
+     *  backends do, some only put it inside `progress`). */
+    chunk?: KgIdSource;
+}
+/** Dispatch a progress event on the global window channel, ensuring the
+ *  payload is tagged with a `kg_id`. Tagging is what allows scoped
+ *  listeners to ignore foreign sessions. */
+declare function dispatchProgressEvent(progress: ProgressEventDetail | null | undefined, options?: DispatchOptions): void;
+interface ScopedReasoningContextValue {
+    /** O(1) predicate: does this scope currently "own" the given KG id?
+     *  Backed by a ref so synchronous adoption updates take effect with
+     *  no React render in between. */
+    hasOwnedKgId: (id: string) => boolean;
+}
+/** Wrap a subtree to claim ownership of one or more KGs.
+ *  Pass a *stable* predicate (memoized via useCallback with empty deps) so
+ *  the context value identity doesn't churn on every render. */
+declare function ScopedReasoningProvider({ hasOwnedKgId, children, }: {
+    hasOwnedKgId: (id: string) => boolean;
+    children: React.ReactNode;
+}): React.FunctionComponentElement<React.ProviderProps<ScopedReasoningContextValue>>;
+/** Subscribe to progress events scoped to a particular KG.
+ *
+ *  Filter rule (single source of truth):
+ *  1. Untagged events → always pass through (backward compat with hosts
+ *     that haven't been updated to propagate kg_id yet).
+ *  2. Tagged events → must match `ownKgId` OR pass the predicate from
+ *     a surrounding `<ScopedReasoningProvider>` (if any).
+ *
+ *  The provider predicate is what enables the chat-panel-spawns-an-ad-hoc-
+ *  session case: the panel mutates its owned-set ref synchronously before
+ *  firing the dispatch, so the child listener sees the new id immediately.
+ */
+declare function useScopedProgressEvent(ownKgId: string | null | undefined, handler: (event: ProgressEventDetail) => void, enabled?: boolean): void;
+
+/** Open an SSE stream against `/pipelines/:run_id/events` and forward each
+ *  parsed `TransformProgress` event to `onProgress`.
+ *
+ *  Pass an `AbortSignal` to make the connection cancellable.
+ *
+ *  410 Gone is surfaced through `onGone` (the run is persisted but inactive
+ *  in memory; the caller is expected to surface a Resume button). Network
+ *  failures bubble through `onError`.
+ *
+ *  As of agents-service v0.3.0 the endpoint requires authentication. The
+ *  `authToken` option is appended as `?access_token=<jwt>` so the request
+ *  works from browser `EventSource`-style fetch streams (which cannot set
+ *  an `Authorization` header). When omitted, the call goes out unauthenticated
+ *  and will 401 in production. */
+declare function openPipelineEventStream(baseUrl: string, runId: string, handlers: {
+    onProgress: (event: ReasoningProgressEvent) => void;
+    onComplete?: () => void;
+    onError?: (error: string) => void;
+    onGone?: (reason: string) => void;
+}, options?: {
+    signal?: AbortSignal;
+    authToken?: string;
+}): Promise<void>;
+
+type GraphLayer = 'document' | 'inferred' | 'agentic' | 'transactional' | 'user';
+/** Annotation as it appears inside a KGSnapshot node/edge. */
+interface KGAnnotation {
+    id: string;
+    agent_id: string;
+    annotation_type: 'support' | 'question' | 'challenge';
+    content: string;
+    resolved: boolean;
+    /** One of: "agent", "human_proxy:<id>", "schema_verifier",
+     *  "file_ingestion:<doc>", "structural_inference". */
+    source?: string;
+}
+/** Node in a `KGSnapshot`. Mirrors `KGNodeSnapshot` from `src/kg/snapshot.rs`. */
+interface KGSnapshotNode {
+    /** Stable string key (e.g. "trustee_1"). */
+    key: string;
+    node_type: string;
+    label: string;
+    description: string;
+    confidence: number;
+    graph_layer: GraphLayer;
+    claim_status: ClaimStatus;
+    settled: boolean;
+    annotation_count: number;
+    unresolved_count: number;
+    created_by: string | null;
+    annotations: KGAnnotation[];
+    has_chunk_links: boolean;
+    /** Surface variants the entity was seen under across chunks
+     *  (accumulated by cross-chunk dedup). Empty when no merges occurred. */
+    aliases?: string[];
+}
+/** Edge in a `KGSnapshot`. */
+interface KGSnapshotEdge {
+    /** Stable string key (e.g. "manages::trustee_1::fund_1"). */
+    key: string;
+    edge_type: string;
+    from_key: string;
+    to_key: string;
+    description: string;
+    strength: number;
+    graph_layer: GraphLayer;
+    claim_status: ClaimStatus;
+    settled: boolean;
+    /** Agent that proposed this edge claim. */
+    created_by: string;
+    /** Pre-rendered "subject [predicate] object" string. */
+    triple: string;
+    annotations: KGAnnotation[];
+    has_chunk_links: boolean;
+}
+/** Full snapshot returned by `GET /kgs/:id`. */
+interface KGSnapshot {
+    /** UUID of the KG (NOT `id`). */
+    kg_id: string | null;
+    name: string;
+    iteration: number;
+    node_count: number;
+    edge_count: number;
+    settled_count: number;
+    unsettled_count: number;
+    layer_counts: Record<GraphLayer, number>;
+    nodes: KGSnapshotNode[];
+    edges: KGSnapshotEdge[];
+}
+/** Single entry in the lineage chain returned by `GET /kgs/:id/lineage`. */
+interface LineageEntry {
+    id: string;
+    name: string;
+    working_group_id: string | null;
+    parent_kg_id: string | null;
+    node_count: number;
+    edge_count: number;
+}
+/** Internal render-shape node consumed by the React Flow layer and
+ *  drawers. Built from a `KGSnapshotNode` via `snapshotToSubgraph`, which
+ *  flattens vocabulary type, claim status, and annotations under
+ *  `properties.*` so downstream renderers keep reading the same paths. */
+interface SubgraphNode {
+    id: string;
+    /** KG id this node belongs to. */
+    kg_id: string;
+    node_key: string;
+    node_type: string;
+    label: string;
+    description: string;
+    properties: Record<string, any>;
+    confidence: number | null;
+    source_agent_key: string | null;
+    iteration: number;
+    status: string;
+    created_at: string;
+    /** Surface variants this entity has been merged from across chunks. */
+    aliases?: string[];
+    /** Graph layer the node belongs to (document / inferred / agentic / user). */
+    graph_layer?: GraphLayer;
+    /** Semantic search score (populated by search results). */
+    score?: number;
+    /** Neighbor node keys (populated by traversal). */
+    neighbors?: string[];
+}
+/** Internal render-shape edge. Mirror of SubgraphNode for edges. */
+interface SubgraphEdge {
+    id: string;
+    kg_id: string;
+    edge_key: string;
+    edge_type: string;
+    from_node_key: string;
+    to_node_key: string;
+    properties: Record<string, any>;
+    strength: number | null;
+    iteration: number;
+    status: string;
+    created_at: string;
+    /** Agent that proposed this claim. */
+    created_by?: string;
+}
+/** KG search result. */
+interface KGSearchResult {
+    hits: SubgraphNode[];
+    traversal: SubgraphNode[];
+}
+/** Chunk reference from a KG node to source text.
+ *
+ *  Also serves as the data shape for the "notes" view — each chunk is a
+ *  human-readable, editable markdown fragment that grounds one or more KG
+ *  entities. `chunk_text` carries the full editable content; `excerpt` is a
+ *  short preview used in the sidebar list.
+ *
+ *  The backend `GET /kgs/:id/chunks` endpoint populates all fields.
+ *  `onLoadNodeChunks` (per-node lookups from the legacy retriever path) may
+ *  still return partial data with `chunk_text` unset, so that field remains
+ *  optional at the type level — callers using it for editing must null-check. */
+interface KGChunkLink$1 {
+    id: string;
+    node_key?: string;
+    edge_key?: string;
+    chunk_id: string;
+    excerpt: string;
+    link_type: string;
+    /** Full markdown content. Populated by `GET /kgs/:id/chunks`; optional on
+     *  legacy paths that don't fetch it. */
+    chunk_text?: string;
+    /** Document id. Required for edit operations; populated by the KG chunks
+     *  endpoint. */
+    document_id?: string;
+    chunk_index?: number;
+    /** Last edit timestamp (ISO 8601). Populated by `GET /kgs/:id/chunks`. */
+    updated_at?: string;
+    /** Parent document title for the editor UI header. Populated by
+     *  `GET /kgs/:id/chunks`. */
+    doc_title?: string;
+}
+/** Response from `POST /chunks/:id` (Phase 4b — note editing). */
+interface SaveNoteResult {
+    chunk_id: string;
+    affected_kgs: string[];
+    orphaned_nodes: number;
+}
+/** Result of creating a manual note via `POST /kgs/:kg_id/chunks` (202).
+ *  The backend persists the chunk immediately and spawns extraction in the
+ *  background. The frontend streams progress via `/pipelines/:run_id/events`
+ *  and refetches chunks when the pipeline completes. */
+interface CreateNoteResult {
+    chunk_id: string;
+    document_id: string;
+    /** Pipeline run id for the extraction pipeline. */
+    run_id: string;
+}
+/** Convert a KGSnapshot to the internal render-shape that the React Flow
+ *  layer + drawers consume. Keeps the existing rendering code untouched. */
+declare function snapshotToSubgraph(snap: KGSnapshot): {
+    nodes: SubgraphNode[];
+    edges: SubgraphEdge[];
+};
+/** Callbacks the host app provides for data fetching. */
+interface KnowledgeGraphDataCallbacks {
+    /** Fetch a KG by id. Backed by `GET /kgs/:id` (optionally with `?layers=...`).
+     *  Returns the full snapshot. The view maps it to its internal shape. */
+    onLoadKg: (groupId: string, kgId: string) => Promise<KGSnapshot>;
+    /** Fetch a KG composed with all its ancestors. Backed by `GET /kgs/:id/composed`.
+     *  Optional — when not wired, the composed view is unavailable. */
+    onLoadComposedKg?: (groupId: string, kgId: string) => Promise<KGSnapshot | null>;
+    /** Walk the parent chain. Backed by `GET /kgs/:id/lineage`. */
+    onLoadLineage?: (groupId: string, kgId: string) => Promise<LineageEntry[]>;
+    /** Search KG nodes semantically (via the chat retriever or a host-defined
+     *  endpoint). The new framework has no dedicated KG-search route, so this
+     *  is fully delegated to the host. */
+    onSearchNodes?: (groupId: string, kgId: string, query: string, limit: number, traversalDepth: number) => Promise<KGSearchResult>;
+    /** Fetch source text chunks for a node. Optional — chunk text comes back
+     *  inline via the chat retriever in the new framework, so this typically
+     *  isn't wired anymore. */
+    onLoadNodeChunks?: (groupId: string, kgId: string, nodeKey: string) => Promise<KGChunkLink$1[]>;
+    /** Fetch ALL chunk links for a KG. Used by the chunk-graph view. */
+    onLoadAllChunks?: (groupId: string, kgId: string) => Promise<KGChunkLink$1[]>;
+    /** Edit a chunk's content (note editing). Backend re-embeds + re-extracts
+     *  for every KG that cited the chunk. Returns the affected KG ids + an
+     *  orphan-node hint. Optional — when not wired, chunk nodes are read-only. */
+    onSaveNote?: (groupId: string, kgId: string, chunkId: string, content: string) => Promise<SaveNoteResult>;
+    /** Create a new note (chunk) in the KG. The backend persists the chunk,
+     *  extracts entities with vocabulary discovery enabled (auto-merge by name),
+     *  and returns the new chunk id plus any newly-discovered vocab types.
+     *  Optional — when not wired, the "New Note" card is hidden. */
+    onCreateNote?: (groupId: string, kgId: string, content: string) => Promise<CreateNoteResult>;
+    /** Post a message to a thread (for the chat panel). */
+    onPostMessage?: (groupId: string, threadId: string, content: string, references?: any) => Promise<any>;
+    /** Load messages from a thread. */
+    onLoadMessages?: (groupId: string, threadId: string) => Promise<any[]>;
+    /** Stream a chat request (for non-reasoning KG chat). Accepts an optional AbortSignal for cancellation. */
+    onStreamRequest?: (body: any, onChunk: (chunk: any) => void, onComplete: () => void, onError: (error: string) => void, signal?: AbortSignal) => Promise<void>;
+    /** Get the active reasoning pipeline for a working group. Returns the
+     *  pipeline run id, the KG id it targets, and (optionally) the
+     *  conversation thread id used for human input. */
+    onGetReasoningSession?: (groupId: string, kgId?: string) => Promise<{
+        run_id?: string;
+        kg_id?: string;
+        thread_id?: string;
+        current_phase?: string;
+    } | null>;
+    /** Get the agents currently active on a pipeline run. Used to populate
+     *  the TeamStage on reload. */
+    onLoadReasoningAgents?: (groupId: string, runId: string) => Promise<Array<{
+        agent_id?: string | null;
+        id?: string | null;
+        display_name?: string | null;
+        role?: string | null;
+        role_in_session?: string | null;
+    }>>;
+}
+
+interface KnowledgeGraphViewProps {
+    groupId: string;
+    /** KG id (kgf.knowledge_graphs.id) to render. */
+    kgId: string;
+    documentId?: string;
+    onClose?: () => void;
+    className?: string;
+    /** Pipeline run id (kgf.pipeline_runs.id) — when set, the chat panel
+     *  subscribes to its events stream so HIL controls work. */
+    runId?: string;
+    /** When set, shows a processing banner and auto-refreshes the graph every 5s */
+    processingDetail?: string | null;
+    /** Generic KG with annotations — for collaborative reasoning mode */
+    genericKG?: GenericKGSnapshot;
+    /** Conversational thread id — when provided, chat panel uses the
+     *  reasoning thread for messages. */
+    threadId?: string;
+    /** Current user for chat attribution */
+    currentUser?: MessageSender;
+    /** Current pipeline phase (e.g. "vocab_discovery", "extraction") */
+    reasoningPhase?: string | null;
+    /** Pre-loaded reasoning agents — used to populate TeamStage on reload */
+    reasoningAgents?: Array<{
+        id: string;
+        display_name: string;
+        role: string;
+    }>;
+    /** Ref to expose chat toggle to parent */
+    chatToggleRef?: React.MutableRefObject<(() => void) | null>;
+    /** Live telemetry events for the activity ticker */
+    activityEvents?: any[];
+    /** Data callbacks — host app provides data fetching */
+    data: KnowledgeGraphDataCallbacks;
+    /** Terminal config for the built-in chat panel. Required unless renderChat is provided. */
+    config?: TerminalConfig;
+    /** Override the built-in chat panel. If not provided, renders GraphChatPanel using config + data callbacks.
+     *
+     *  `onHighlightNodes` is the hook the chat panel calls when the AI
+     *  response mentions KG nodes — the custom chat panel should forward
+     *  it to its `GraphChatPanel` (or equivalent) so cited nodes get the
+     *  same dim/highlight treatment the built-in chat gives them. */
+    renderChat?: (props: {
+        groupId: string;
+        kgId: string;
+        runId?: string;
+        threadId?: string;
+        reasoningPhase?: string | null;
+        currentUser?: any;
+        rawNodes: SubgraphNode[];
+        onHighlightNodes: (nodeIds: string[]) => void;
+    }) => React.ReactNode;
+    /** Optional: ontology/vocabulary panel renderer. Rendered in the right panel when ontology button is clicked. */
+    renderOntologyPanel?: (props: {
+        groupId: string;
+        documentId?: string;
+        rawNodes: SubgraphNode[];
+        rawEdges: SubgraphEdge[];
+        onClose: () => void;
+    }) => React.ReactNode;
+    /**
+     * "Open dossier →" callback (Phase 4 click-through). When provided,
+     * the NodeDetailDrawer renders a button that routes the host app
+     * to the entity's detail page in the active lens. The host
+     * receives the node's frame_id + concept_type and constructs the
+     * URL (typically `/crm/:kind/:id?lens=:current_lens`). When
+     * omitted, the drawer stays read-only — preserving the legacy
+     * behavior for hosts that haven't migrated.
+     */
+    onOpenDossier?: (params: {
+        frameId: string;
+        conceptType: string;
+    }) => void;
+}
+declare function KnowledgeGraphView({ groupId, kgId, documentId, onClose, className, runId, processingDetail, genericKG: genericKGProp, threadId, currentUser, reasoningPhase, reasoningAgents, chatToggleRef, activityEvents, data, config, renderChat, renderOntologyPanel, onOpenDossier, }: KnowledgeGraphViewProps): react_jsx_runtime.JSX.Element;
+
+interface GraphChatPanelProps {
+    groupId: string;
+    /** KG id (kgf.knowledge_graphs.id) this panel is bound to. */
+    kgId: string;
+    /** Pipeline run id, when there's an active reasoning pipeline targeting this KG. */
+    runId?: string;
+    /** Optional thread id used for the conversational pause loop. */
+    threadId?: string;
+    rawNodes: SubgraphNode[];
+    onHighlightNodes?: (nodeIds: string[]) => void;
+    currentUser?: MessageSender;
+    /** Terminal config — host app provides */
+    config: TerminalConfig;
+    /** Load messages from a thread */
+    onLoadMessages?: (groupId: string, threadId: string) => Promise<any[]>;
+    /** Post a message to a thread */
+    onPostMessage?: (groupId: string, threadId: string, content: string, references?: any) => Promise<any>;
+    /** Stream a chat request. Accepts an optional AbortSignal for cancellation. */
+    onStreamChat?: (body: any, onChunk: (chunk: StreamChunk) => void, onComplete: () => void, onError: (error: string) => void, signal?: AbortSignal) => Promise<void>;
+    /** True when viewing a previously completed KG (not live) */
+    isLoadedSession?: boolean;
+    /** True when a live reasoning session is active — disables standalone streaming even before thread ID arrives */
+    isLiveReasoning?: boolean;
+    /** Current pipeline phase — used to seed PipelineProgressBar on mount when no live events have fired yet */
+    reasoningPhase?: string | null;
+    /** Bearer JWT — forwarded to the pipeline SSE keepalive as `?access_token=`
+     *  since browser fetch SSE can't set `Authorization`. The agents service
+     *  requires auth on /pipelines/:run_id/events (v0.3.0+). */
+    authToken?: string;
+}
+declare function GraphChatPanel({ groupId, kgId, runId, threadId, rawNodes, onHighlightNodes, currentUser, config, onLoadMessages, onPostMessage, onStreamChat, isLoadedSession, isLiveReasoning, reasoningPhase, authToken, }: GraphChatPanelProps): react_jsx_runtime.JSX.Element;
+
+interface ReasoningViewProps {
+    /** Terminal/chat configuration */
+    config: TerminalConfig;
+    /** Working group ID */
+    groupId: string;
+    /** KG id (kgf.knowledge_graphs.id) — replaces the legacy `reasoningSetId`. */
+    kgId: string;
+    /** Pipeline run id (kgf.pipeline_runs.id) — when the KG is the target
+     *  of an in-flight reasoning pipeline, this powers HIL controls. */
+    runId?: string;
+    /** Conversational thread id — enables reasoning-aware chat (polling thread messages) */
+    threadId?: string;
+    /** Current user for chat attribution */
+    currentUser?: MessageSender;
+    /** Called when user closes the view */
+    onClose?: () => void;
+    /** Live KG snapshot — for active reasoning sessions (real-time updates via SSE) */
+    genericKG?: GenericKGSnapshot;
+    /** Current pipeline phase label */
+    reasoningPhase?: string | null;
+    /** Data callbacks for the KG visualization */
+    data: KnowledgeGraphDataCallbacks;
+    /** Optional: title shown in header */
+    title?: string;
+    /** Optional: description/subtitle */
+    description?: string;
+    /** Optional: node/edge counts for header */
+    nodeCount?: number;
+    edgeCount?: number;
+    /** Optional: status badge */
+    status?: string;
+    /** Problem statement / reasoning goal — shown prominently in header */
+    problem?: string;
+    /** Called when the user wants to chain a new reasoning pipeline whose
+     *  parent KG is this one. The host typically posts to
+     *  `POST /kgs/:kgId/reason-over` and the resulting child KG inherits
+     *  this KG's vocabulary. The `parentKgId` argument is the current KG id. */
+    onChainSession?: (parentKgId: string, problem: string) => void;
+    /** Live telemetry events for the activity ticker on the KG canvas */
+    activityEvents?: any[];
+    /** Load messages from a thread */
+    onLoadMessages?: (groupId: string, threadId: string) => Promise<any[]>;
+    /** Post a message to a thread */
+    onPostMessage?: (groupId: string, threadId: string, content: string, references?: any) => Promise<any>;
+    /** Stream a chat request. Accepts an optional AbortSignal for cancellation. */
+    onStreamChat?: (body: any, onChunk: (chunk: StreamChunk) => void, onComplete: () => void, onError: (error: string) => void, signal?: AbortSignal) => Promise<void>;
+    className?: string;
+}
+/**
+ * ReasoningView — the full reasoning experience.
+ * Renders a KG graph on the left and a reasoning chat on the right.
+ * This is the primary way users interact with reasoning sets.
+ */
+declare function ReasoningView({ config, groupId, kgId, runId, threadId, currentUser, onClose, genericKG, reasoningPhase, data, title, description, nodeCount, edgeCount, status, onLoadMessages, onPostMessage, onStreamChat, problem, onChainSession, activityEvents, className, }: ReasoningViewProps): react_jsx_runtime.JSX.Element;
+
+interface GraphNodeData extends Record<string, unknown> {
+    label: string;
+    description: string;
+    nodeType: string;
+    confidence?: number;
+    source?: string;
+    iteration?: number;
+    status?: string;
+    properties?: Record<string, any>;
+    /** Surface variants this entity has been merged from across chunks
+     *  (cross-chunk dedup). Empty when no merges. */
+    aliases?: string[];
+    /** Graph layer (document / inferred / agentic / user). Surfaces
+     *  provenance as a badge in the detail drawer. */
+    graphLayer?: string;
+    hasRagChunks?: boolean;
+    isHighlighted?: boolean;
+    isDimmed?: boolean;
+    isTraversal?: boolean;
+    searchScore?: number | null;
+    settled?: boolean;
+    annotationCount?: number;
+    unresolvedCount?: number;
+    phase?: 'problem' | 'solution' | 'simple';
+    claimStatus?: string;
+    /** Transient flag — true for nodes that were just added by a re-extraction.
+     *  Triggers an orange "freshly added" glow that the parent KGV clears after
+     *  a few seconds via setNodes. */
+    recentlyAdded?: boolean;
+}
+declare function GraphNodeComponent({ data, selected }: NodeProps & {
+    data: GraphNodeData;
+}): react_jsx_runtime.JSX.Element;
+declare const GraphNode: React.MemoExoticComponent<typeof GraphNodeComponent>;
+
+interface GraphEdgeData extends Record<string, unknown> {
+    edgeType: string;
+    strength?: number;
+    label?: string;
+    /** Source node label — used to render the full claim triple */
+    sourceLabel?: string;
+    /** Target node label — used to render the full claim triple */
+    targetLabel?: string;
+    /** Agent that proposed this claim */
+    createdBy?: string;
+    properties?: Record<string, any>;
+    isHighlighted?: boolean;
+    isDimmed?: boolean;
+    claimStatus?: string;
+}
+declare function GraphEdgeComponent({ id, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, data, selected, }: EdgeProps & {
+    data: GraphEdgeData;
+}): react_jsx_runtime.JSX.Element;
+declare const GraphEdge: React.MemoExoticComponent<typeof GraphEdgeComponent>;
+/** SVG defs for arrow markers — render inside ReactFlow */
+declare function EdgeMarkerDefs(): react_jsx_runtime.JSX.Element;
+
+interface SettlementBarProps {
+    settledCount: number;
+    totalCount: number;
+}
+declare function SettlementBar({ settledCount, totalCount }: SettlementBarProps): react_jsx_runtime.JSX.Element;
+
+/** Chunk reference from a KG node to source text. */
+interface KGChunkLink {
+    id: string;
+    node_key?: string;
+    edge_key?: string;
+    chunk_id: string;
+    excerpt: string;
+    link_type: string;
+    chunk_text?: string;
+}
+/** Diff summary returned from a save when re-extraction ran. Mirrors the
+ *  shape returned by the backend `reextract_chunk` endpoint. */
+interface SaveDiffSummary {
+    added_node_keys?: string[];
+    removed_node_keys?: string[];
+    added_edge_keys?: string[];
+    removed_edge_keys?: string[];
+    orphaned_node_keys?: string[];
+}
+/** Result returned by `onSaveDescription` so the drawer can show a diff
+ *  summary in the success pill. All fields optional — a void return is also
+ *  accepted (treated as a no-info save). */
+interface SaveDescriptionResult {
+    diff?: SaveDiffSummary;
+}
+interface NodeDetailDrawerProps {
+    node: GraphNodeData & {
+        id: string;
+    };
+    connectedNodes: Array<{
+        id: string;
+        label: string;
+        nodeType: string;
+        edgeType: string;
+        direction: 'in' | 'out';
+    }>;
+    chunks?: KGChunkLink[];
+    annotations?: Annotation[];
+    onClose: () => void;
+    onNavigate: (nodeId: string) => void;
+    /**
+     * Optional save handler. When provided, the description gets a pencil
+     * affordance and the editor commits via this callback. Async — should
+     * resolve only after the new content is durably persisted (or reject on
+     * error so we surface the failure to the user). The optional return value
+     * lets callers ship a diff summary that the drawer surfaces in its success
+     * pill. When omitted, the description is read-only.
+     */
+    onSaveDescription?: (newContent: string) => Promise<SaveDescriptionResult | void>;
+    /**
+     * Hint about what the save callback does. `fast` = content + embedding
+     * only (~500ms). `reextract` = full pipeline including KG re-extraction
+     * (~5-15s). Used to set expectations in the loading message.
+     */
+    saveMode?: 'fast' | 'reextract';
+    /** Ordered list of node IDs for review navigation. When provided,
+     *  prev/next buttons appear in the header. */
+    reviewNodeIds?: string[];
+    /** Called when the user clicks prev/next in the review nav. */
+    onReviewNavigate?: (nodeId: string) => void;
+    /**
+     * "Open dossier →" callback (Phase 4 click-through). When provided,
+     * the drawer renders a button at the top that routes the host app
+     * to the entity's detail page in the current lens. Receives the
+     * node's frame_id + concept_type so the host can build the URL.
+     * Optional: when omitted, no dossier link is shown — drawer
+     * remains read-only as before.
+     */
+    onOpenDossier?: (params: {
+        frameId: string;
+        conceptType: string;
+    }) => void;
+}
+declare function NodeDetailDrawer({ node, connectedNodes, chunks, annotations, onClose, onNavigate, onSaveDescription, saveMode, reviewNodeIds, onReviewNavigate, onOpenDossier }: NodeDetailDrawerProps): react_jsx_runtime.JSX.Element;
+
+interface EdgeDetailDrawerProps {
+    edge: {
+        id: string;
+        edgeType: string;
+        strength?: number;
+        label?: string;
+        triple?: string;
+        settled?: boolean;
+        properties?: Record<string, any>;
+        createdBy?: string;
+        sourceNode: {
+            id: string;
+            label: string;
+            nodeType: string;
+        };
+        targetNode: {
+            id: string;
+            label: string;
+            nodeType: string;
+        };
+    };
+    annotations?: Annotation[];
+    onClose: () => void;
+    onNavigate: (nodeId: string) => void;
+}
+declare function EdgeDetailDrawer({ edge, annotations, onClose, onNavigate }: EdgeDetailDrawerProps): react_jsx_runtime.JSX.Element;
+
+interface ClaimNodeData extends Record<string, unknown> {
+    /** Full triple: "Subject predicate Object" */
+    triple: string;
+    subjectLabel: string;
+    predicate: string;
+    objectLabel: string;
+    claimStatus?: string;
+    settled?: boolean;
+    createdBy?: string;
+    annotationCount?: number;
+    unresolvedCount?: number;
+    confidence?: number;
+    isHighlighted?: boolean;
+    isDimmed?: boolean;
+}
+declare function ClaimNodeComponent({ data, selected }: NodeProps & {
+    data: ClaimNodeData;
+}): react_jsx_runtime.JSX.Element;
+declare const ClaimNode: React.MemoExoticComponent<typeof ClaimNodeComponent>;
+
+/**
+ * Claims projection — transforms the entity graph into a claims graph
+ * where edges become nodes and shared entities become connectors.
+ *
+ * Entity view:  [Company] --issues--> [Equity]
+ * Claims view:  [Company issues Equity] --Company-- [Company files Registration]
+ */
+
+declare function buildClaimsGraph(nodes: SubgraphNode[], edges: SubgraphEdge[]): {
+    rfNodes: Node[];
+    rfEdges: Edge[];
+};
+
+interface AnnotationThreadProps {
+    annotations: Annotation[];
+    settled: boolean;
+}
+declare function AnnotationThread({ annotations, settled }: AnnotationThreadProps): react_jsx_runtime.JSX.Element;
+
+/** Entity mention descriptor for inline highlighting. */
+interface EntityMention {
+    id: string;
+    label: string;
+    nodeType: string;
+}
+interface MarkdownContentProps {
+    /** Markdown source. Falsy values render nothing. */
+    children: string | null | undefined;
+    /** Extra classes appended to the wrapper. */
+    className?: string;
+    /** Entities to highlight as inline mentions within the text. */
+    entities?: EntityMention[];
+    /** Called when the user clicks a highlighted entity mention. */
+    onEntityClick?: (entityId: string) => void;
+}
+/**
+ * Renders markdown text with refined dark-themed typography for the knowledge
+ * graph drawers. Self-contained — does not require @tailwindcss/typography.
+ *
+ * When `entities` are provided, occurrences of entity labels in the text are
+ * highlighted as colored inline pills.
+ */
+declare const MarkdownContent: React.NamedExoticComponent<MarkdownContentProps>;
+
+interface MarkdownEditorProps {
+    /** Initial markdown source. Read once on mount; further parent updates are ignored. */
+    value: string;
+    /** Called on every keystroke with the latest markdown. */
+    onChange: (next: string) => void;
+    /** Called when the user commits the edit (⌘↵ or Save). */
+    onSave: () => void;
+    /** Called when the user discards (Esc or Cancel). */
+    onCancel: () => void;
+    /** Optional placeholder shown when the editor is empty. */
+    placeholder?: string;
+    /** Whether to autofocus the editor on mount. Defaults to true. */
+    autoFocus?: boolean;
+    /**
+     * When true, disables the Save / Cancel buttons and the ⌘↵ / Esc keyboard
+     * shortcuts. The contenteditable itself stays interactive so the user can
+     * keep editing while a save is in flight, but no second save can fire.
+     * Used to prevent double-submits during long-running re-extraction.
+     */
+    disabled?: boolean;
+}
+/**
+ * A WYSIWYG markdown editor for the knowledge graph drawers, built on
+ * MDXEditor (Lexical under the hood). You see formatted text as you type —
+ * `## Heading` instantly becomes a heading, `**bold**` collapses into bold,
+ * `- ` becomes a bullet, etc.
+ *
+ * Themed to match the drawer with our orange brand accent. Save/Cancel are
+ * exposed as a footer with ⌘↵ / Esc keyboard shortcuts.
+ */
+declare const MarkdownEditor: React.NamedExoticComponent<MarkdownEditorProps>;
+
+interface ActivityItem {
+    id: string;
+    icon: string;
+    text: string;
+    color: string;
+    timestamp: number;
+}
+interface LiveActivityTickerProps {
+    items: ActivityItem[];
+    maxVisible?: number;
+}
+/**
+ * A persistent live activity feed on the KG canvas.
+ * Shows the most recent items. New items slide in, old ones slide out.
+ * Always shows at least the latest item — never empties while reasoning is active.
+ */
+declare function LiveActivityTicker({ items, maxVisible }: LiveActivityTickerProps): react_jsx_runtime.JSX.Element;
+/** Convert a ReasoningProgressEvent into an ActivityItem (or null to skip) */
+declare function eventToActivity(event: any): ActivityItem | null;
+
+interface AgentStatus {
+    id: string;
+    displayName: string;
+    role?: string;
+    status: 'idle' | 'thinking' | 'done' | 'active';
+}
+interface AgentPresenceBarProps {
+    /** If true, listens for yf-progress-event window events to track agents */
+    listenForEvents?: boolean;
+    /** Alternatively, pass agents directly */
+    agents?: AgentStatus[];
+    /** KG this bar belongs to — events from other KGs are ignored */
+    kgId?: string;
+}
+/**
+ * Compact presence bar showing which agents are in the reasoning session.
+ * Tracks agent status from SSE progress events via window events.
+ */
+declare function AgentPresenceBar({ listenForEvents, agents: agentsProp, kgId }: AgentPresenceBarProps): react_jsx_runtime.JSX.Element;
+
+type Stage = 'idle' | 'team_formation' | 'schema_seeding' | 'doc_preparing' | 'doc_extracting' | 'doc_linking' | 'doc_storing' | 'graph';
+interface StageAgent {
+    id: string;
+    display_name: string;
+    role: string;
+    expertise?: string[];
+    focus?: string;
+    personality?: string;
+}
+interface StageState {
+    stage: Stage;
+    team: StageAgent[];
+    /** Ids of agents the user added locally that the backend has not (yet)
+     *  acknowledged. Tracked separately from the agent objects so the agent
+     *  shape stays clean and downstream consumers don't have to know about
+     *  this internal flag. */
+    localOnlyAgentIds: Set<string>;
+    /** Ids of agents from the most recent backend TeamSetup. Used to detect
+     *  wholesale-replace events ("give me a different team"): if the next
+     *  TeamSetup arrives with zero overlap with this set, we drop the local
+     *  additions instead of carrying them forward as ghosts. */
+    lastBackendTeamIds: Set<string>;
+    schemaNodeTypes: string[];
+    schemaEdgeTypes: string[];
+    schemaRelationships: Array<{
+        name: string;
+        domain: string[];
+        range: string[];
+    }>;
+    schemaNodeTypeCount: number;
+    schemaEdgeTypeCount: number;
+    docTitle: string;
+    docActivity: ActivityItem[];
+}
+interface StageCanvasProps {
+    nodeCount: number;
+    onForceGraph: () => void;
+    /** Initialize to a specific phase on mount (e.g. from session status endpoint) */
+    initialPhase?: string;
+    /** Pre-populate team agents on mount (e.g. from reasoning set agents) */
+    initialTeam?: StageState['team'];
+    /** KG this canvas belongs to — required to filter out global events
+     *  from other KGs that share the same window event channel. */
+    kgId?: string;
+}
+declare function StageCanvas({ nodeCount, onForceGraph, initialPhase, initialTeam, kgId }: StageCanvasProps): react_jsx_runtime.JSX.Element;
+
+interface ReasoningOverlayProps {
+    /** Terminal config for the chat panel */
+    config: TerminalConfig;
+    /** Current user for chat attribution */
+    currentUser?: MessageSender;
+    /** Data callbacks for the KG visualization */
+    data: KnowledgeGraphDataCallbacks;
+    /** Look up the working group + thread for a KG. Replaces the legacy
+     *  `onLookupReasoningSet`. The host typically resolves this by walking
+     *  the KG's lineage (`GET /kgs/:id/lineage` returns `working_group_id`
+     *  on each `LineageEntry`) and asking the agents service for the
+     *  active reasoning session via `onGetReasoningSession`. */
+    onLookupKg?: (kgId: string) => Promise<{
+        working_group_id: string;
+        thread_id?: string;
+        run_id?: string;
+    } | null>;
+    /** Bearer JWT — forwarded to the chat panel's pipeline-events SSE keepalive
+     *  as `?access_token=` because browser fetch SSE can't set `Authorization`
+     *  and the agents service enforces auth (v0.3.0+). */
+    authToken?: string;
+}
+/**
+ * Global fullscreen overlay for viewing knowledge graphs.
+ * Listens for `view-kg` window events and opens on top of any page.
+ * Self-contained — fetches its own data via the host-provided callbacks,
+ * no navigation needed.
+ */
+declare function ReasoningOverlay({ config, currentUser, data, onLookupKg, authToken }: ReasoningOverlayProps): react_jsx_runtime.JSX.Element;
+
+interface PipelineProgressBarProps {
+    /** Listen for yf-progress-event window events */
+    listenForEvents?: boolean;
+    /** Or pass the current phase directly */
+    currentPhase?: string;
+    /** Phases that have been completed */
+    completedPhases?: string[];
+    /** KG this bar belongs to — events from other KGs are ignored */
+    kgId?: string;
+}
+/**
+ * Horizontal step indicator showing pipeline progress.
+ * Team → Schema → Building → Review → Synthesis → Done
+ */
+declare function PipelineProgressBar({ listenForEvents, currentPhase: currentPhaseProp, completedPhases: completedProp, kgId }: PipelineProgressBarProps): react_jsx_runtime.JSX.Element;
+
+type CheckpointType = 'schema' | 'review' | 'synthesis' | 'team' | 'generic';
+interface CheckpointCardProps {
+    /** Which checkpoint this is */
+    type: CheckpointType;
+    /** Main content / summary */
+    content: string;
+    /** KG stats */
+    nodeCount?: number;
+    edgeCount?: number;
+    /** Convergence state */
+    convergence?: {
+        ontological: boolean;
+        epistemic: boolean;
+        converged: boolean;
+    };
+    /** Schema stats (for schema checkpoint) */
+    schemaStats?: {
+        nodeTypes: number;
+        edgeTypes: number;
+        hasConstraints: boolean;
+    };
+    /** Called when user picks an action */
+    onAction: (action: 'proceed' | 'question' | 'change', message?: string) => void;
+    /** Whether user has already responded */
+    responded?: boolean;
+}
+declare function CheckpointCard({ type, content, nodeCount, edgeCount, convergence, schemaStats, onAction, responded, }: CheckpointCardProps): react_jsx_runtime.JSX.Element;
+
+interface ConstructionProgressProps {
+    /** KG this indicator belongs to — events from other KGs are ignored */
+    kgId?: string;
+}
+/**
+ * Compact per-transform progress indicator.
+ *
+ * Activates for any transform that iterates turns: reasoning's construction
+ * phase AND file extraction / structural completion's per-input loops. The
+ * reasoning-specific fields (schema errors, ontological / epistemic
+ * convergence) hide themselves when their source events never fire, so
+ * extraction runs show only the relevant columns (turn counter + node/edge
+ * count) without confusing "○ ontology ○ claims" dots.
+ *
+ * Listens for yf-progress-event window events.
+ */
+declare function ConstructionProgress({ kgId }?: ConstructionProgressProps): react_jsx_runtime.JSX.Element;
+
+/** Structured detail from the file→KG processing pipeline */
+type ProcessingDetail = {
+    type: 'chunking';
+    message: string;
+} | {
+    type: 'embedding_chunks';
+    chunk_count: number;
+} | {
+    type: 'storing_document';
+} | {
+    type: 'vocabulary_started';
+} | {
+    type: 'extraction_started';
+    total_chunks: number;
+} | {
+    type: 'chunk_processed';
+    chunk: number;
+    total: number;
+    new_entities: number;
+    new_edges: number;
+    total_entities: number;
+    total_edges: number;
+} | {
+    type: 'vocabulary_evolved';
+    chunk: number;
+    new_types: number;
+    total_node_types: number;
+    total_edge_types: number;
+} | {
+    type: 'semantic_dedup';
+    chunk: number;
+    proposed_key: string;
+    matched_key: string;
+} | {
+    type: 'edge_dropped';
+    chunk: number;
+    from: string;
+    to: string;
+    reason: string;
+} | {
+    type: 'extraction_complete';
+    entities: number;
+    edges: number;
+} | {
+    type: 'structural_started';
+    candidates: number;
+} | {
+    type: 'structural_validated';
+    from_label: string;
+    to_label: string;
+    rel_type: string;
+} | {
+    type: 'structural_complete';
+    inferred: number;
+    rejected: number;
+    yield_pct: number;
+} | {
+    type: 'storage_started';
+} | {
+    type: 'storage_progress';
+    stored: number;
+    total: number;
+} | {
+    type: 'storage_complete';
+    nodes: number;
+    edges: number;
+    chunk_links?: number;
+} | {
+    type: 'embedding_started';
+    entity_count: number;
+} | {
+    type: 'embedding_complete';
+} | {
+    type: 'error';
+    message: string;
+};
+interface DocumentProcessingEvent {
+    type: 'DocumentProcessing';
+    document_id: string;
+    step: 'processing' | 'vocabulary' | 'extracting' | 'linking' | 'storing' | 'embedding' | 'complete' | 'error';
+    progress: number | null;
+    detail: ProcessingDetail | string | null;
+    /** KG id (kgf.knowledge_graphs.id) the upload pipeline targets. Replaces
+     *  the legacy `reasoning_set_id` field that the backend used to send. */
+    kg_id: string | null;
+}
+/** Convert a DocumentProcessing detail into an ActivityItem for the ticker */
+declare function documentEventToActivity(detail: ProcessingDetail | string | null): ActivityItem | null;
+/** Pipeline phase labels for the progress indicator */
+declare const DOCUMENT_PIPELINE_STEPS: {
+    key: string;
+    label: string;
+}[];
+
+/**
+ * Compact progress indicator for file→KG document processing.
+ * Listens for yf-doc-processing window events.
+ */
+declare function DocumentProcessingProgress(): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hierarchical layout using dagre — clean, readable, no overlaps.
+ * Uses LR (left-to-right) for wide screens, compact spacing.
+ */
+declare function layoutGraph(nodes: Node[], edges: Edge[]): Node[];
+
+/** Node type → visual properties mapping for the knowledge graph */
+declare const NODE_TYPE_COLORS: Record<string, {
+    bg: string;
+    border: string;
+    badge: string;
+    text: string;
+}>;
+declare function getNodeColors(nodeType: string): {
+    bg: string;
+    border: string;
+    badge: string;
+    text: string;
+};
+/** Claim status → border/badge color overrides */
+declare const CLAIM_STATUS_COLORS: Record<string, {
+    border: string;
+    badge: string;
+    opacity: number;
+}>;
+declare function getClaimStatusColors(status?: string): {
+    border: string;
+    badge: string;
+    opacity: number;
+};
+declare const NODE_TYPE_LABELS: Record<string, string>;
+declare function getNodeTypeLabel(nodeType: string): string;
+declare function getVocabTypeColors(vocabType: string): {
+    bg: string;
+    border: string;
+    badge: string;
+    text: string;
+};
+declare function getVocabTypeLabel(vocabType: string): string;
+/** Edge type → visual properties */
+declare const EDGE_TYPE_COLORS: Record<string, string>;
+declare function getEdgeColor(edgeType: string): string;
+declare function getEdgeTypeLabel(edgeType: string): string;
+
+declare const terminalColors: {
+    promptDot: string;
+    promptDollar: string;
+    promptText: string;
+    promptSymbol: string;
+    bgPrimary: string;
+    bgHeader: string;
+    bgInput: string;
+    borderPrimary: string;
+    borderSecondary: string;
+    textPrimary: string;
+    textSecondary: string;
+    textMuted: string;
+    textPlaceholder: string;
+    textSystem: string;
+    textCommand: string;
+    textError: string;
+    textSuccess: string;
+    buttonBg: string;
+    buttonText: string;
+    buttonHover: string;
+    cursor: string;
+    suggestionBg: string;
+    suggestionCard: string;
+    suggestionCardHover: string;
+    suggestionHighlight: string;
+};
+declare const terminalClassNames: {
+    promptDollar: string;
+    promptDot: string;
+    promptText: string;
+    promptSymbol: string;
+};
+
+export { ADVANCE_PHASE_SIGNAL, AGENT_PALETTE, type AIAction, type ActivityItem, AgentAvatar, type AgentAvatarProps, type AgentAvatarSize, AgentPresenceBar, type Annotation, AnnotationThread, type ApiEndpoint, type ApiParameter, type BaseTerminalProps, CLAIM_STATUS_COLORS, ChatTerminal, type ChatTerminalProps, CheckpointCard, type CheckpointType, ClaimNode, type ClaimNodeData, type ClaimStatus, ConstructionProgress, CoreTerminal, type CoreTerminalProps, type CreateNoteResult, DOCUMENT_PIPELINE_STEPS, type DocumentProcessingEvent, DocumentProcessingProgress, EDGE_TYPE_COLORS, EdgeDetailDrawer, EdgeMarkerDefs, CoreTerminal as EmbeddedTerminal, type CoreTerminalProps as EmbeddedTerminalProps, ExpandableTerminal, type ExpandableTerminalProps, type FileUploadResult, type GapOption, type GapQuestion, type GenericKGSnapshot, type GenericSnapshotEdge, type GenericSnapshotNode, GraphChatPanel, type GraphChatPanelProps, GraphEdge, type GraphEdgeData, type GraphLayer, GraphNode, type GraphNodeData, type HelpTopic, InlineTerminal, type InlineTerminalProps, type KGAnnotation, type KGChunkLink$1 as KGChunkLink, type KGScope, type KGSearchResult, type KGSnapshot, type KGSnapshotEdge, type KGSnapshotNode, type KnowledgeGraphDataCallbacks, KnowledgeGraphView, LIVE_KG_ID, type LegacyKGSnapshot, type LegacyKGSnapshotEdge, type LegacyKGSnapshotNode, type LineageEntry, type ListRagFilesResult, type ListedRagFile, LiveActivityTicker, MarkdownContent, MarkdownEditor, type Mention, type MentionTarget, type MessageAudience, type MessageSender, NODE_TYPE_COLORS, NODE_TYPE_LABELS, NodeDetailDrawer, PROGRESS_EVENT_NAME, type PageSuggestion, type ParsedCommand, type PipelineBuilderAction, type PipelineDraft, type PipelineDraftStep, PipelineProgressBar, type PluginContext, type ProcessingDetail, type ProgressEventDetail, type ProgressState, type RagFileActionResult, ReasoningHistoryCard, ReasoningOverlay, type ReasoningOverlayProps, type ReasoningProgressEvent, type ReasoningSnapshot, ReasoningView, type ReasoningViewProps, SYNTHESIS_DONE_SIGNAL, type SaveNoteResult, ScopedReasoningProvider, SettlementBar, type SlashMentionCandidate, SlashMentionPicker, StageCanvas, StandardTerminal, type StandardTerminalProps, type StreamChunk, type StreamHandler, type StreamHandlers, type SubgraphEdge, type SubgraphNode, type TeamSetupAgent, type TerminalCommand, type TerminalCommandResult, type TerminalConfig, type TerminalEntry, TerminalInputBar, type TerminalInputBarProps, type TerminalPlugin, type TerminalSlots, type TerminalSource, type TerminalTheme, TerminalThemeProvider, type TerminalWidget, type WorkingGroupContext, agentSeed, avatarColor, blueScope, buildClaimsGraph, buildTerminalCommand, buttonShadow, captureReasoningSnapshot, defaultTheme, dispatchProgressEvent, documentEventToActivity, emeraldCollab, emeraldRevised, eventToActivity, extractKGSources, extractKgId, filterCommands, formatAssetDisplay, formatPaymentAmount, formatTokenAssetId, getAgentColor, getBuiltInCommands, getClaimStatusColors, getEdgeColor, getEdgeTypeLabel, getNodeColors, getNodeTypeLabel, getVocabTypeColors, getVocabTypeLabel, greenAction, handleSSEStream, handleStreamingResponse, hostApp, initials, isFixedKgId, isNaturalLanguage, layoutGraph, mergeTheme, openPipelineEventStream, orangeRebuttal, parseTerminalCommand, pipelineBg, processStreamLines, purple, reduceProgress, renderMarkdownBlock, resolvePaymentAssetDisplay, snapshotToSubgraph, terminalClassNames, terminalColors, useScopedProgressEvent, useSlashMentionPicker, useTheme, warmBg };