@stigmer/react 0.5.1 → 1.0.1

package/src/execution/__tests__/useContextWindow.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  AgentExecutionSchema,
+  AgentExecutionStatusSchema,
+  type AgentExecution,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import {
+  ContextInfoSchema,
+  SummarizationEventSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/context_pb";
+import { useContextWindow } from "../useContextWindow";
+
+function makeExecution(overrides?: {
+  currentTokenCount?: number;
+  contextWindowLimit?: number;
+  triggerThreshold?: number;
+  targetTokens?: number;
+  summarizationEnabled?: boolean;
+  utilizationPercent?: number;
+}): AgentExecution {
+  const exec = create(AgentExecutionSchema);
+  const status = create(AgentExecutionStatusSchema);
+  const contextInfo = create(ContextInfoSchema);
+
+  contextInfo.currentTokenCount = overrides?.currentTokenCount ?? 10_000;
+  contextInfo.contextWindowLimit = overrides?.contextWindowLimit ?? 200_000;
+  contextInfo.summarizationTriggerThreshold = overrides?.triggerThreshold ?? 180_000;
+  contextInfo.summarizationTargetTokens = overrides?.targetTokens ?? 160_000;
+  contextInfo.summarizationEnabled = overrides?.summarizationEnabled ?? true;
+  contextInfo.utilizationPercent = overrides?.utilizationPercent ?? 5;
+
+  status.contextInfo = contextInfo;
+  exec.status = status;
+  return exec;
+}
+
+function makeExecutionWithSummarization(): AgentExecution {
+  const exec = makeExecution({
+    currentTokenCount: 80_000,
+    contextWindowLimit: 200_000,
+    utilizationPercent: 40,
+  });
+
+  const event = create(SummarizationEventSchema);
+  event.timestamp = "2026-05-16T10:30:00.000Z";
+  event.tokensBefore = 180_000;
+  event.tokensAfter = 80_000;
+  event.compressionRatio = 0.56;
+  event.durationMs = 2300;
+  event.summarizationModel = "claude-haiku-4";
+  event.messagesBefore = 42;
+  event.messagesAfter = 12;
+  event.summarizationCostUsd = 0.0008;
+
+  exec.status!.contextInfo!.summarizationEvents.push(event);
+  return exec;
+}
+
+describe("useContextWindow", () => {
+  it("returns empty state when execution is null", () => {
+    const { result } = renderHook(() => useContextWindow(null));
+
+    expect(result.current.hasContextInfo).toBe(false);
+    expect(result.current.health).toBe("healthy");
+    expect(result.current.currentTokenCount).toBe(0);
+    expect(result.current.summarizationEvents).toHaveLength(0);
+  });
+
+  it("returns empty state when execution has no context_info", () => {
+    const exec = create(AgentExecutionSchema);
+    exec.status = create(AgentExecutionStatusSchema);
+
+    const { result } = renderHook(() => useContextWindow(exec));
+
+    expect(result.current.hasContextInfo).toBe(false);
+  });
+
+  it("returns empty state when context_window_limit is 0", () => {
+    const exec = makeExecution({ contextWindowLimit: 0 });
+
+    const { result } = renderHook(() => useContextWindow(exec));
+
+    expect(result.current.hasContextInfo).toBe(false);
+  });
+
+  it("extracts context info correctly for healthy utilization", () => {
+    const exec = makeExecution({
+      currentTokenCount: 42_000,
+      contextWindowLimit: 200_000,
+      triggerThreshold: 180_000,
+      targetTokens: 160_000,
+      utilizationPercent: 21,
+    });
+
+    const { result } = renderHook(() => useContextWindow(exec));
+
+    expect(result.current.hasContextInfo).toBe(true);
+    expect(result.current.currentTokenCount).toBe(42_000);
+    expect(result.current.contextWindowLimit).toBe(200_000);
+    expect(result.current.utilizationPercent).toBe(21);
+    expect(result.current.triggerThreshold).toBe(180_000);
+    expect(result.current.targetTokens).toBe(160_000);
+    expect(result.current.summarizationEnabled).toBe(true);
+    expect(result.current.health).toBe("healthy");
+    expect(result.current.isNearThreshold).toBe(false);
+  });
+
+  it("returns warning health for 70-90% utilization", () => {
+    const exec = makeExecution({ utilizationPercent: 75 });
+
+    const { result } = renderHook(() => useContextWindow(exec));
+
+    expect(result.current.health).toBe("warning");
+  });
+
+  it("returns critical health for 90%+ utilization", () => {
+    const exec = makeExecution({ utilizationPercent: 92 });
+
+    const { result } = renderHook(() => useContextWindow(exec));
+
+    expect(result.current.health).toBe("critical");
+  });
+
+  it("detects near-threshold correctly", () => {
+    const exec = makeExecution({
+      currentTokenCount: 172_000,
+      contextWindowLimit: 200_000,
+      triggerThreshold: 180_000,
+      utilizationPercent: 86,
+    });
+
+    const { result } = renderHook(() => useContextWindow(exec));
+
+    expect(result.current.isNearThreshold).toBe(true);
+  });
+
+  it("maps summarization events correctly", () => {
+    const exec = makeExecutionWithSummarization();
+
+    const { result } = renderHook(() => useContextWindow(exec));
+
+    expect(result.current.summarizationEvents).toHaveLength(1);
+
+    const event = result.current.summarizationEvents[0];
+    expect(event.tokensBefore).toBe(180_000);
+    expect(event.tokensAfter).toBe(80_000);
+    expect(event.compressionRatio).toBeCloseTo(0.56);
+    expect(event.durationMs).toBe(2300);
+    expect(event.model).toBe("claude-haiku-4");
+    expect(event.messagesBefore).toBe(42);
+    expect(event.messagesAfter).toBe(12);
+    expect(event.costUsd).toBeCloseTo(0.0008);
+  });
+
+  it("returns stable reference across re-renders with same input", () => {
+    const exec = makeExecution();
+    const { result, rerender } = renderHook(() => useContextWindow(exec));
+
+    const first = result.current;
+    rerender();
+    const second = result.current;
+
+    expect(second).toBe(first);
+  });
+});

package/src/execution/index.ts

@@ -13,6 +13,25 @@ export type { UseExecutionStreamReturn } from "./useExecutionStream";
 export { UsageWidget, formatCost, formatTokenCount } from "./UsageWidget";
 export type { UsageWidgetProps } from "./UsageWidget";
 
+export { useContextWindow } from "./useContextWindow";
+export type {
+  ContextHealth,
+  SummarizationEventView,
+  UseContextWindowReturn,
+} from "./useContextWindow";
+
+export { ContextGauge } from "./ContextGauge";
+export type { ContextGaugeProps } from "./ContextGauge";
+
+export { SummarizationBadge } from "./SummarizationBadge";
+export type { SummarizationBadgeProps } from "./SummarizationBadge";
+
+export { SummarizationCard } from "./SummarizationCard";
+export type { SummarizationCardProps } from "./SummarizationCard";
+
+export { PlanCompletionCard } from "./PlanCompletionCard";
+export type { PlanCompletionCardProps } from "./PlanCompletionCard";
+
 export { useExecutionArtifacts } from "./useExecutionArtifacts";
 export type { UseExecutionArtifactsReturn } from "./useExecutionArtifacts";
 
@@ -38,6 +57,9 @@ export type { ArtifactRenderMode } from "./artifact-utils";
 export { ExecutionPhaseBadge } from "./ExecutionPhaseBadge";
 export type { ExecutionPhaseBadgeProps } from "./ExecutionPhaseBadge";
 
+export { InteractionModeBadge } from "./InteractionModeBadge";
+export type { InteractionModeBadgeProps } from "./InteractionModeBadge";
+
 export { SetupProgress } from "./SetupProgress";
 export type { SetupProgressProps } from "./SetupProgress";
 

package/src/execution/useContextWindow.ts

@@ -0,0 +1,148 @@
+"use client";
+
+import { useMemo } from "react";
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { SummarizationEvent } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/context_pb";
+
+/**
+ * Context window health state derived from utilization percentage.
+ *
+ * Matches the thresholds documented in context.proto (ContextInfo.utilization_percent):
+ * - 0-70%:  healthy (green)
+ * - 70-90%: warning (yellow, approaching summarization threshold)
+ * - 90%+:   critical (red, at or above trigger threshold)
+ */
+export type ContextHealth = "healthy" | "warning" | "critical";
+
+/** Normalized view of a single summarization event for rendering. */
+export interface SummarizationEventView {
+  readonly timestamp: string;
+  readonly tokensBefore: number;
+  readonly tokensAfter: number;
+  readonly compressionRatio: number;
+  readonly durationMs: number;
+  readonly model: string;
+  readonly messagesBefore: number;
+  readonly messagesAfter: number;
+  readonly costUsd: number;
+}
+
+/** Return value of {@link useContextWindow}. */
+export interface UseContextWindowReturn {
+  /** `true` when real `ContextInfo` data is available (native harness). */
+  readonly hasContextInfo: boolean;
+  /** Current token count in the context window. 0 when unavailable. */
+  readonly currentTokenCount: number;
+  /** Model's maximum context window size in tokens. 0 when unavailable. */
+  readonly contextWindowLimit: number;
+  /** Context utilization as a percentage (0-100). 0 when unavailable. */
+  readonly utilizationPercent: number;
+  /** Token threshold that triggers summarization. 0 when unavailable. */
+  readonly triggerThreshold: number;
+  /** Target token count after summarization. 0 when unavailable. */
+  readonly targetTokens: number;
+  /** Whether automatic summarization is enabled for this execution. */
+  readonly summarizationEnabled: boolean;
+  /** Summarization events ordered chronologically (oldest first). */
+  readonly summarizationEvents: readonly SummarizationEventView[];
+  /** Derived health state based on utilization thresholds. */
+  readonly health: ContextHealth;
+  /** `true` when utilization is within 5% of the trigger threshold. */
+  readonly isNearThreshold: boolean;
+}
+
+const HEALTHY_CEILING = 70;
+const WARNING_CEILING = 90;
+const NEAR_THRESHOLD_MARGIN = 5;
+
+const EMPTY: UseContextWindowReturn = {
+  hasContextInfo: false,
+  currentTokenCount: 0,
+  contextWindowLimit: 0,
+  utilizationPercent: 0,
+  triggerThreshold: 0,
+  targetTokens: 0,
+  summarizationEnabled: false,
+  summarizationEvents: [],
+  health: "healthy",
+  isNearThreshold: false,
+};
+
+function deriveHealth(utilization: number): ContextHealth {
+  if (utilization >= WARNING_CEILING) return "critical";
+  if (utilization >= HEALTHY_CEILING) return "warning";
+  return "healthy";
+}
+
+function mapEvent(e: SummarizationEvent): SummarizationEventView {
+  return {
+    timestamp: e.timestamp,
+    tokensBefore: e.tokensBefore,
+    tokensAfter: e.tokensAfter,
+    compressionRatio: e.compressionRatio,
+    durationMs: e.durationMs,
+    model: e.summarizationModel,
+    messagesBefore: e.messagesBefore,
+    messagesAfter: e.messagesAfter,
+    costUsd: e.summarizationCostUsd,
+  };
+}
+
+/**
+ * Extracts context window information from an execution's status.
+ *
+ * Provides real-time visibility into context utilization, summarization
+ * thresholds, and summarization history for the native harness. Returns
+ * a stable empty state when `ContextInfo` is absent (e.g., Cursor harness
+ * where context is managed externally).
+ *
+ * The derived `health` and `isNearThreshold` fields are intended for
+ * driving visual indicators (gauge color, alert badges) without coupling
+ * rendering components to threshold arithmetic.
+ *
+ * @param execution - The execution snapshot from `useExecutionStream`, or `null`.
+ *
+ * @example
+ * ```tsx
+ * const { execution } = useExecutionStream(executionId);
+ * const ctx = useContextWindow(execution);
+ *
+ * if (ctx.hasContextInfo) {
+ *   return <ContextGauge {...ctx} />;
+ * }
+ * ```
+ */
+export function useContextWindow(
+  execution: AgentExecution | null,
+): UseContextWindowReturn {
+  const contextInfo = execution?.status?.contextInfo ?? null;
+
+  const events = useMemo(() => {
+    if (!contextInfo?.summarizationEvents?.length) return [];
+    return contextInfo.summarizationEvents.map(mapEvent);
+  }, [contextInfo?.summarizationEvents]);
+
+  return useMemo((): UseContextWindowReturn => {
+    if (!contextInfo || contextInfo.contextWindowLimit === 0) return EMPTY;
+
+    const utilization = contextInfo.utilizationPercent;
+    const trigger = contextInfo.summarizationTriggerThreshold;
+    const triggerPercent =
+      trigger > 0 && contextInfo.contextWindowLimit > 0
+        ? (trigger / contextInfo.contextWindowLimit) * 100
+        : WARNING_CEILING;
+
+    return {
+      hasContextInfo: true,
+      currentTokenCount: contextInfo.currentTokenCount,
+      contextWindowLimit: contextInfo.contextWindowLimit,
+      utilizationPercent: utilization,
+      triggerThreshold: trigger,
+      targetTokens: contextInfo.summarizationTargetTokens,
+      summarizationEnabled: contextInfo.summarizationEnabled,
+      summarizationEvents: events,
+      health: deriveHealth(utilization),
+      isNearThreshold: utilization >= triggerPercent - NEAR_THRESHOLD_MARGIN,
+    };
+  }, [contextInfo, events]);
+}

package/src/execution/useCreateAgentExecution.ts

@@ -2,9 +2,15 @@
 
 import { useCallback, useState } from "react";
 import type { AttachmentInput, EnvVarInput } from "@stigmer/sdk";
+import { InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { useStigmer } from "../hooks";
 import { toError } from "../internal/toError";
 
+const INTERACTION_MODE_MAP: Record<string, InteractionMode> = {
+  agent: InteractionMode.AGENT,
+  plan: InteractionMode.PLAN,
+};
+
 /** Input for {@link UseCreateAgentExecutionReturn.create}. */
 export interface CreateAgentExecutionInput {
   /** Organization slug that owns the session. */
@@ -43,6 +49,15 @@ export interface CreateAgentExecutionInput {
    * files from their mount paths (default `/inputs/{filename}`).
    */
   readonly attachments?: AttachmentInput[];
+  /**
+   * Interaction mode for this execution.
+   *
+   * - `"agent"` (default): full tool access.
+   * - `"plan"`: read-only analysis, no file mutations.
+   *
+   * Maps to `ExecutionConfig.interaction_mode` in the proto.
+   */
+  readonly interactionMode?: "agent" | "plan";
 }
 
 /** Resolved output of {@link UseCreateAgentExecutionReturn.create}. */
@@ -120,15 +135,23 @@ export function useCreateAgentExecution(): UseCreateAgentExecutionReturn {
       setError(null);
 
       try {
+        const hasConfig = input.modelName || input.interactionMode;
+        const executionConfig = hasConfig
+          ? {
+              ...(input.modelName ? { modelName: input.modelName } : {}),
+              ...(input.interactionMode
+                ? { interactionMode: INTERACTION_MODE_MAP[input.interactionMode] ?? InteractionMode.UNSPECIFIED }
+                : {}),
+            }
+          : undefined;
+
         const execution = await stigmer.agentExecution.create({
           name: `execution-${Date.now()}`,
           org: input.org,
           sessionId: input.sessionId,
           agentId: input.agentId,
           message: input.message,
-          executionConfig: input.modelName
-            ? { modelName: input.modelName }
-            : undefined,
+          executionConfig,
           runtimeEnv: input.runtimeEnv,
           attachments: input.attachments,
         });

package/src/index.ts

@@ -128,6 +128,19 @@ export type {
   SearchResultGroup,
 } from "./session";
 
+// Activity — unified recent activity (sessions + workflow executions)
+export {
+  useRecentActivity,
+  groupRecentActivityByTime,
+} from "./activity";
+export type {
+  RecentActivityType,
+  RecentActivityEntry,
+  RecentActivityGroup,
+  UseRecentActivityOptions,
+  UseRecentActivityReturn,
+} from "./activity";
+
 // Execution — behavior hooks, styled components, and utilities (AgentExecution aggregate)
 export {
   isTerminalPhase,
@@ -135,6 +148,7 @@ export {
   useExecutionStream,
   useSubmitApproval,
   ExecutionPhaseBadge,
+  InteractionModeBadge,
   SetupProgress,
   ExecutionProgress,
   TodoList,
@@ -142,6 +156,11 @@ export {
   findActiveTodo,
   todoCompletionSummary,
   UsageWidget,
+  ContextGauge,
+  SummarizationBadge,
+  SummarizationCard,
+  PlanCompletionCard,
+  useContextWindow,
   formatCost,
   formatTokenCount,
   ToolCallGroup,
@@ -191,10 +210,18 @@ export type {
   UseExecutionStreamReturn,
   UseSubmitApprovalReturn,
   ExecutionPhaseBadgeProps,
+  InteractionModeBadgeProps,
   SetupProgressProps,
   ExecutionProgressProps,
   TodoListProps,
   UsageWidgetProps,
+  ContextGaugeProps,
+  SummarizationBadgeProps,
+  SummarizationCardProps,
+  PlanCompletionCardProps,
+  ContextHealth,
+  SummarizationEventView,
+  UseContextWindowReturn,
   ToolCallGroupProps,
   ToolCallDetailProps,
   McpToolDetailProps,
@@ -253,12 +280,16 @@ export type {
 export {
   useComposer,
   SessionComposer,
+  InteractionModePicker,
 } from "./composer";
 export type {
   UseComposerOptions,
   UseComposerReturn,
+  SessionComposerHandle,
   SessionComposerProps,
   SessionComposerSubmitContext,
+  InteractionModePickerProps,
+  InteractionModeOption,
 } from "./composer";
 
 // MCP Server — data hook, count hook, list hook, search hook, picker, config panel, tool selector, detail view, setup orchestration, OAuth connect, and update
@@ -1073,3 +1104,194 @@ export type {
   ResourceWorkbenchProps,
   ResourceAvatarProps,
 } from "./resource-workbench";
+
+// Workflow — data hooks, styled components, task kind registry
+export {
+  TaskKindRegistryContext,
+  useTaskKindRegistry,
+  useWorkflow,
+  useWorkflowList,
+  useWorkflowCount,
+  useWorkflowInstances,
+  useWorkflowExecutionList,
+  useWorkflowExecution,
+  useWorkflowExecutionEventLog,
+  useWorkflowExecutionArtifacts,
+  useWorkflowExecutionEventStream,
+  useWorkflowExecutionActions,
+  WorkflowExecutionPhaseBadge,
+  WorkflowTaskList,
+  WorkflowDetailView,
+  WorkflowExecutionViewer,
+  WorkflowExecutionHeader,
+  WorkflowExecutionTimeline,
+  WorkflowExecutionTaskPanel,
+  WorkflowExecutionCostPanel,
+  WorkflowExecutionArtifactPanel,
+  WorkflowExecutionApprovalCard,
+  serializeWorkflowYaml,
+  parseWorkflowYaml,
+  useWorkflowYaml,
+  useWorkflowSave,
+  useWorkflowValidation,
+  useWorkflowTopology,
+  WorkflowYamlEditor,
+  WorkflowTopologyGraph,
+  useWorkflowEditor,
+  WorkflowEditorView,
+  useRunWorkflowFlow,
+  WorkflowRunForm,
+  WorkflowRunDialog,
+  useWorkflowDashboardSummary,
+  usePendingApprovals,
+  ExecutionSummaryWidget,
+  PendingApprovalsWidget,
+  FailedRunsWidget,
+  WorkflowDashboard,
+  START_NODE_ID,
+  END_NODE_ID,
+  yamlToGraph,
+  graphToYaml,
+  graphToWorkflowInput,
+  useWorkflowCanvas,
+  TASK_KIND_DRAG_MIME,
+  WorkflowCanvasEditor,
+  WorkflowTaskPalette,
+  TaskPickerPopover,
+  CanvasContextMenu,
+  WorkflowInspectorPanel,
+  TaskConfigForm,
+  BranchConditionBuilder,
+  ApprovalFormBuilder,
+  useResolveAgentExecutionSession,
+  CostByWorkflowChart,
+  ExecutionTrendChart,
+  extractWorkflowYaml,
+  useWorkflowArchitectFlow,
+  WorkflowArchitectDialog,
+  useRefineWorkflowFlow,
+  WorkflowRefinePanel,
+  computeUnifiedDiff,
+  useDiagnoseExecutionFlow,
+  WorkflowRepairCard,
+  STARTER_WORKFLOW_YAML,
+} from "./workflow";
+export type {
+  TaskKindDescriptor,
+  TaskKindCategory,
+  TaskFieldDescriptor,
+  TaskFieldType,
+  TaskFieldGroup,
+  TaskKindRegistryState,
+  UseTaskKindRegistryReturn,
+  UseWorkflowReturn,
+  UseWorkflowListOptions,
+  UseWorkflowListReturn,
+  UseWorkflowCountOptions,
+  UseWorkflowCountReturn,
+  UseWorkflowInstancesReturn,
+  UseWorkflowExecutionListOptions,
+  UseWorkflowExecutionListReturn,
+  UseWorkflowExecutionReturn,
+  UseWorkflowExecutionEventLogOptions,
+  UseWorkflowExecutionEventLogReturn,
+  UseWorkflowExecutionArtifactsReturn,
+  UseWorkflowExecutionEventStreamOptions,
+  UseWorkflowExecutionEventStreamReturn,
+  UseWorkflowExecutionActionsReturn,
+  WorkflowExecutionPhaseBadgeProps,
+  WorkflowTaskListProps,
+  WorkflowDetailViewProps,
+  WorkflowExecutionViewerProps,
+  WorkflowExecutionHeaderProps,
+  WorkflowExecutionTimelineProps,
+  WorkflowExecutionTaskPanelProps,
+  WorkflowExecutionCostPanelProps,
+  WorkflowExecutionArtifactPanelProps,
+  WorkflowExecutionApprovalCardProps,
+  UseWorkflowYamlReturn,
+  UseWorkflowSaveReturn,
+  UseWorkflowValidationReturn,
+  UseWorkflowTopologyReturn,
+  TopologyNode,
+  TopologyEdge,
+  TopologyNodeCategory,
+  WorkflowYamlEditorProps,
+  WorkflowTopologyGraphProps,
+  UseWorkflowEditorOptions,
+  UseWorkflowEditorReturn,
+  WorkflowEditorViewProps,
+  WorkflowEditorMode,
+  UseRunWorkflowFlowOptions,
+  UseRunWorkflowFlowReturn,
+  RunWorkflowFieldErrors,
+  WorkflowRunFormProps,
+  WorkflowRunDialogProps,
+  UseWorkflowDashboardSummaryOptions,
+  UseWorkflowDashboardSummaryReturn,
+  UsePendingApprovalsOptions,
+  UsePendingApprovalsReturn,
+  ExecutionSummaryWidgetProps,
+  PendingApprovalsWidgetProps,
+  FailedRunsWidgetProps,
+  WorkflowDashboardProps,
+  WorkflowGraphModel,
+  WorkflowGraphNode,
+  WorkflowGraphEdge,
+  WorkflowGraphDocument,
+  WorkflowGraphEnvVar,
+  WorkflowGraphBudget,
+  CanvasSelection,
+  UseWorkflowCanvasReturn,
+  WorkflowCanvasEditorProps,
+  WorkflowTaskPaletteProps,
+  TaskPickerPopoverProps,
+  CanvasContextMenuProps,
+  CanvasContextMenuTarget,
+  WorkflowInspectorPanelProps,
+  TaskConfigFormProps,
+  BranchConditionBuilderProps,
+  ApprovalFormBuilderProps,
+  UseResolveAgentExecutionSessionReturn,
+  CostByWorkflowChartProps,
+  ExecutionTrendChartProps,
+  ExtractedWorkflowYaml,
+  ArchitectPhase,
+  UseWorkflowArchitectFlowOptions,
+  UseWorkflowArchitectFlowReturn,
+  WorkflowArchitectDialogProps,
+  RefinePhase,
+  UseRefineWorkflowFlowOptions,
+  UseRefineWorkflowFlowReturn,
+  WorkflowRefinePanelProps,
+  DiffLine as WorkflowDiffLine,
+  DiffLineType as WorkflowDiffLineType,
+  DiagnosePhase,
+  UseDiagnoseExecutionFlowOptions,
+  UseDiagnoseExecutionFlowReturn,
+  WorkflowRepairCardProps,
+} from "./workflow";
+
+// ─── Dashboard (Unified Platform) ──────────────────────────────────────────
+export {
+  // Types
+  type DashboardSummary,
+  type DashboardFailedRun,
+  // Data Hooks
+  useAgentExecutionSummary,
+  AgentExecutionSummaryTimeWindow,
+  type UseAgentExecutionSummaryOptions,
+  type UseAgentExecutionSummaryReturn,
+  useDashboardSummary,
+  type UseDashboardSummaryOptions,
+  type UseDashboardSummaryReturn,
+  useDashboardFailedRuns,
+  type UseDashboardFailedRunsReturn,
+  // Styled Components
+  DashboardKPICards,
+  type DashboardKPICardsProps,
+  DashboardFailedRuns,
+  type DashboardFailedRunsProps,
+  OperationalDashboard,
+  type OperationalDashboardProps,
+} from "./dashboard";

package/src/internal/VirtualizedThread.tsx

@@ -37,6 +37,7 @@ export interface VirtualizedThreadProps {
   readonly submittingApprovalIds?: ReadonlySet<string>;
   readonly filePathCtx: FilePathContextValue;
   readonly sandboxCtx: SandboxContextValue;
+  readonly onBuildFromPlan?: () => void;
 }
 
 // ---------------------------------------------------------------------------
@@ -93,6 +94,7 @@ export function VirtualizedThread({
   submittingApprovalIds,
   filePathCtx,
   sandboxCtx,
+  onBuildFromPlan,
 }: VirtualizedThreadProps) {
   const virtuosoRef = useRef<VirtuosoHandle>(null);
   const scrollerRef = useRef<HTMLDivElement | null>(null);
@@ -121,8 +123,9 @@ export function VirtualizedThread({
       formatToolCallSummary,
       onApprovalSubmit,
       submittingApprovalIds,
+      onBuildFromPlan,
     }),
-    [formatToolCallSummary, onApprovalSubmit, submittingApprovalIds],
+    [formatToolCallSummary, onApprovalSubmit, submittingApprovalIds, onBuildFromPlan],
   );
 
   return (