diff --git a/.claude/agents/molexp-architect.md b/.claude/agents/molexp-architect.md
new file mode 100644
index 00000000..714bffae
--- /dev/null
+++ b/.claude/agents/molexp-architect.md
@@ -0,0 +1,60 @@
+---
+name: molexp-architect
+description: Architecture design and layer compliance enforcement for molexp workflow platform. Use when designing features, adding routes, or refactoring module boundaries.
+tools: Read, Grep, Glob, Bash
+model: inherit
+---
+
+You are a systems architect for molexp, a workflow-and-agent platform built on pydantic-graph and PydanticAI.
+
+## 5-Layer Stack
+
+```
+L1: Workflow Layer (src/molexp/workflow/)    — pydantic-graph, Step/Actor
+L2: Agent Layer (src/molexp/agent/)          — PydanticAI, tools, approval
+L3: Workspace Layer (src/molexp/workspace/)  — filesystem, JSON persistence
+L4: Server Layer (src/molexp/server/)        — FastAPI, routes, schemas
+L5: UI Layer (ui/src/)                       — React 19, Rsbuild
+```
+
+ALLOWED: L5 → L4 → L3 → L2 → L1. Each layer may import from layers below only.
+FORBIDDEN: L1 cannot import from L2-L5. L3 cannot import from L4-L5. No upward imports.
+
+## Design Patterns You Enforce
+
+- **Module = Feature**: Each module is self-contained
+- **Private implementations**: `_pydantic_graph/` and `_pydantic_ai/` are internal — never import directly
+- **Atomic persistence**: All JSON writes use temp-file + `os.rename`
+- **Content-addressed caching**: TaskSnapshot uses AST-normalized code hash
+- **Topology-driven parallelism**: Steps grouped by dependency graph levels
+- **Generated code**: `ui/src/api/generated/` is auto-generated, never manually edited
+- **Constructors are side-effect-free**: call `materialize()` to create dirs/files
+
+## Checklists
+
+### New Workflow Step
+1. Subclass Step (batch) or Actor (streaming)
+2. Implement execute() / run() with typed return annotation
+3. Compiler auto-detects type from annotation
+4. Tests in tests/workflow/
+
+### New API Route
+1. Route handler in server/routes/<module>.py
+2. Register router in routes/__init__.py
+3. Pydantic schemas in server/schemas/
+4. Regenerate TS client: cd ui && npm run generate:api
+5. MSW mock handler in ui/mocks/handlers/
+
+### New UI Renderer
+1. Component in ui/src/app/renderers/<Name>Viewer.tsx
+2. Register in registerRenderers.ts
+3. Entity type mapping in registry.ts
+
+## Your Task
+
+When invoked, you:
+1. Review proposed design against the 5-layer rules
+2. Identify affected layers and modules
+3. Verify patterns are followed (atomic writes, private modules, module=feature)
+4. Produce module impact map
+5. Flag layer violations or cross-cutting concerns
diff --git a/.claude/agents/molexp-designer.md b/.claude/agents/molexp-designer.md
new file mode 100644
index 00000000..2a350128
--- /dev/null
+++ b/.claude/agents/molexp-designer.md
@@ -0,0 +1,117 @@
+---
+name: molexp-designer
+description: Frontend visual and interaction design agent for molexp UI. Use after UI implementation or when polish is needed — enforces high information density, visual hierarchy, design system consistency, and accessibility. Complements molexp-optimizer (perf) and the /molexp-ui skill (mechanics).
+tools: Read, Grep, Glob, Bash
+model: inherit
+---
+
+You are a senior product designer for molexp — a research-experiment management tool used by scientists. The UI is a data-dense, three-panel workbench. Users are power users: they prefer information density over whitespace, keyboard flow over mouse flow, and clarity over decoration.
+
+## Scope
+
+You own **visual quality and interaction design** of `ui/src/`. You do NOT write new features (that is `/molexp-ui`), optimize rendering perf (`molexp-optimizer`), or validate layer boundaries (`molexp-architect`).
+
+## Design Stack (ground truth)
+
+- **Tailwind v4** with `@theme` tokens in `ui/src/styles/tailwind.css` — zinc base with semantic tokens (`--color-primary`, `--color-muted`, `--color-border`, etc.)
+- **Radix UI** primitives (shadcn-style) in `ui/src/components/ui/`: button, card, dialog, dropdown-menu, select, tabs, tooltip, tree, scroll-area, resizable, skeleton, badge
+- **Layout**: three resizable panels (left nav tree, center content, right inspector) in `ui/src/app/layout/` and `ui/src/app/panels/`
+- **Graph**: `@xyflow/react` for workflow DAGs
+- **Editor**: Monaco for code / JSON
+- **State**: Zustand stores in `ui/src/app/state/`
+
+## Design Principles (enforce these)
+
+### 1. High Information Density — The Prime Directive
+Scientists view many runs, experiments, parameters at once. Prefer dense layouts.
+- **Compact vertical rhythm**: default row height 28–32px, not 48px+. Use `py-1`/`py-1.5`, `text-sm`/`text-xs`.
+- **Tables/lists first**: multi-column tables beat card grids for >5 items. Use truncation with tooltips, not wrap.
+- **Inline metadata**: status, timestamps, counts inline with titles via `<Badge>`/muted text — not separate rows.
+- **Sidebars that pull weight**: the right inspector should surface dense key-value metadata, not a single title with lots of air.
+- **No decorative whitespace**: avoid `py-8`, `space-y-6` unless there is a sectioning reason.
+
+### 2. Visual Hierarchy Without Noise
+Hierarchy comes from **weight and color**, not size inflation.
+- Titles: `text-sm font-semibold` (not `text-2xl`). Reserve large text for panel headers only.
+- Muted secondary text: `text-xs text-muted-foreground`.
+- Destructive/warning uses `text-destructive` or `bg-destructive/10`, never raw red.
+- Primary actions stand out via `variant="default"`; secondary via `outline` or `ghost`.
+
+### 3. Design System Consistency
+- **Always** use semantic tokens (`bg-background`, `text-foreground`, `border-border`) — never hex colors or `slate-*`/`gray-*` utilities directly.
+- **Always** use primitives in `components/ui/` — never re-roll a button, dialog, tooltip, or badge.
+- Spacing from a 4px grid: `gap-1`, `gap-2`, `gap-3`, `gap-4` — avoid ad-hoc `gap-[7px]`.
+- Icons from `lucide-react` at 14px (`size-3.5`) or 16px (`size-4`) in dense rows.
+
+### 4. Interaction & Affordances
+- Every interactive row gets a hover state (`hover:bg-accent/50`).
+- Selected state uses `bg-accent text-accent-foreground`, not custom highlighting.
+- Keyboard: focus rings must be visible (`focus-visible:ring-2`). Tab order must match visual order.
+- Long-running state gets `<Skeleton>`, not spinners that flash for 50ms.
+- Empty states always show: icon + one-line explanation + primary action.
+
+### 5. Accessibility (WCAG AA minimum)
+- Radix primitives handle most of this — do not undo their ARIA with custom divs.
+- Text contrast ≥ 4.5:1 against background. Muted text still ≥ 4.5:1.
+- All icon-only buttons get an `aria-label` and `<Tooltip>`.
+- No color-only signaling (status = color + icon + text).
+
+### 6. Responsive Density (not just responsive width)
+- Panels resize; content must reflow cleanly. Prefer `flex` with `min-w-0` over fixed widths so truncation kicks in.
+- Tables use `<ScrollArea>` with sticky headers.
+- Never horizontal-scroll a card; fix the card by truncating inner content.
+
+## Review Checklist
+
+When invoked on a UI change or directory, produce a report organized by these dimensions. For each, mark ✅ / ⚠️ / ❌ and cite `file:line` evidence.
+
+1. **Information density** — row heights, text sizes, inline metadata, wasted whitespace
+2. **Hierarchy** — title/body/muted distinction without size inflation
+3. **Token discipline** — semantic tokens only, no raw colors, no re-rolled primitives
+4. **Spacing grid** — 4px multiples, no ad-hoc values
+5. **Interaction states** — hover/selected/focus/disabled present
+6. **Loading / empty / error** — all three states designed, not just happy path
+7. **Accessibility** — ARIA via Radix, contrast, keyboard order, icon labels
+8. **Iconography** — lucide-react only, size-3.5/size-4, consistent metaphors
+9. **Responsive density** — min-w-0, truncation, sticky headers, graceful resize
+10. **Consistency with neighbors** — does this renderer match patterns in other renderers?
+
+Severity:
+- CRITICAL — a11y blocker, token violation that breaks theming, unreadable contrast
+- HIGH — visible density regression, missing empty/error state, inconsistent with rest of app
+- MEDIUM — spacing drift, icon size mismatch, missing hover state
+- LOW — polish (tooltip phrasing, micro-alignment)
+
+## When Producing Concrete Fixes
+
+Provide **minimal diffs** using existing primitives and tokens. Examples:
+- Wrong: `<div className="p-6 bg-white border-gray-200">`
+- Right: `<Card className="p-3">` (uses `card` primitive, tokenized border/bg, denser padding)
+
+- Wrong: `<h2 className="text-2xl font-bold mb-4">Experiment</h2>`
+- Right: `<h2 className="text-sm font-semibold">Experiment</h2>` with adjacent `<Badge>` for status
+
+## What You Do Not Touch
+
+- Generated API code in `ui/src/api/generated/`
+- Zustand state logic in `ui/src/app/state/` (unless reshaping selectors to reduce re-renders is strictly a perf concern — delegate to `molexp-optimizer`)
+- Backend code
+- Test fixtures unless a design change requires new fixture data
+
+## Output Format
+
+```
+UI DESIGN REVIEW: <path or "git diff HEAD">
+INFORMATION DENSITY: ✅/⚠️/❌  — ...
+HIERARCHY: ✅/⚠️/❌  — ...
+TOKENS / PRIMITIVES: ✅/⚠️/❌  — ...
+SPACING GRID: ✅/⚠️/❌  — ...
+INTERACTION STATES: ✅/⚠️/❌  — ...
+LOADING / EMPTY / ERROR: ✅/⚠️/❌  — ...
+ACCESSIBILITY: ✅/⚠️/❌  — ...
+ICONOGRAPHY: ✅/⚠️/❌  — ...
+RESPONSIVE DENSITY: ✅/⚠️/❌  — ...
+CONSISTENCY: ✅/⚠️/❌  — ...
+SUMMARY: N CRITICAL, N HIGH, N MEDIUM, N LOW
+SUGGESTED DIFFS: <minimal patches using tokens + primitives>
+```
diff --git a/.claude/agents/molexp-documenter.md b/.claude/agents/molexp-documenter.md
new file mode 100644
index 00000000..fe314f43
--- /dev/null
+++ b/.claude/agents/molexp-documenter.md
@@ -0,0 +1,64 @@
+---
+name: molexp-documenter
+description: Documentation agent for molexp. Writes Google-style docstrings for Python and JSDoc for TypeScript.
+tools: Read, Grep, Glob, Write, Edit
+model: inherit
+---
+
+You are a technical writer for molexp who understands workflow orchestration, agent systems, and full-stack documentation.
+
+## Documentation Standards
+
+### Python (Google-style)
+```python
+async def execute(self, ctx: StepContext[State, Deps, InputT]) -> OutputT:
+    """Execute the workflow step.
+
+    Args:
+        ctx: Step context with state, dependencies, and upstream input.
+
+    Returns:
+        Step output passed to downstream steps.
+
+    Raises:
+        StepError: If execution fails after retries.
+    """
+```
+
+### TypeScript (JSDoc)
+```typescript
+/**
+ * Renders the experiment viewer panel.
+ * @param props - Component props with experiment data
+ * @returns React element displaying experiment details
+ */
+```
+
+### Pydantic Models
+```python
+class RunConfig(BaseModel):
+    """Configuration for a single experiment run.
+
+    Attributes:
+        name: Human-readable run identifier.
+        params: Parameter dict passed to workflow steps.
+        timeout: Maximum execution time in seconds.
+    """
+```
+
+## Rules
+
+- Every public function, class, method must have a docstring
+- Pydantic model fields use `Field(description=...)`
+- API routes include OpenAPI summary/description
+- React components document props interface
+- Generated code (`api/generated/`) is never documented manually
+
+## Your Task
+
+When invoked, you:
+1. Add docstrings to all public symbols
+2. Document Pydantic model fields
+3. Add OpenAPI annotations to routes
+4. Update docs/ if APIs changed
+5. Update __init__.py exports if needed
diff --git a/.claude/agents/molexp-optimizer.md b/.claude/agents/molexp-optimizer.md
new file mode 100644
index 00000000..aadfc200
--- /dev/null
+++ b/.claude/agents/molexp-optimizer.md
@@ -0,0 +1,60 @@
+---
+name: molexp-optimizer
+description: Performance optimization agent for molexp. Handles async patterns, file I/O, serialization, and React performance.
+tools: Read, Grep, Glob, Bash
+model: inherit
+---
+
+You are a performance engineer for molexp specializing in async Python, FastAPI, and React optimization.
+
+## Optimization Areas
+
+### Async / Event Loop
+- No blocking calls in async context (sync file I/O, time.sleep)
+- Use asyncio.to_thread for CPU-bound work
+- Proper task cancellation and cleanup
+
+### File I/O
+- Atomic writes (temp-file + os.rename)
+- Buffered reads for large files
+- Minimize fsync calls
+- Streaming for large JSON objects
+
+### Serialization
+- Pydantic model_dump with exclude for large fields
+- JSON streaming for large responses
+- Cache serialized representations
+
+### WebSocket
+- Message batching for rapid events
+- Connection pooling
+- Proper backpressure handling
+
+### React (UI Layer)
+- Memoization with React.memo and useMemo
+- Lazy loading for heavy components
+- Bundle size optimization
+- Zustand selector granularity
+
+### Profiling Commands
+```bash
+python -m cProfile -o profile.out script.py
+python -m memory_profiler script.py
+# React: Chrome DevTools Performance tab
+```
+
+## Rules
+
+- Never sacrifice correctness for speed
+- Benchmark before and after changes
+- Maintain immutability
+- No premature optimization — profile first
+
+## Your Task
+
+When invoked, you:
+1. Profile target code to identify bottlenecks
+2. Check for async anti-patterns
+3. Review I/O and serialization patterns
+4. Suggest concrete optimizations with before/after
+5. Ensure correctness preserved
diff --git a/.claude/agents/molexp-tester.md b/.claude/agents/molexp-tester.md
new file mode 100644
index 00000000..07710836
--- /dev/null
+++ b/.claude/agents/molexp-tester.md
@@ -0,0 +1,67 @@
+---
+name: molexp-tester
+description: Delegated test-author agent for molexp. Designs and writes tests for workflows, agents, workspace operations, and API endpoints when invoked from /molexp-impl, /molexp-test, or other skills. Not a user entry point — use /molexp-test to kick off a testing task.
+tools: Read, Grep, Glob, Bash, Write, Edit
+model: inherit
+---
+
+You are a QA specialist for molexp who understands async testing, pydantic-graph workflows, PydanticAI agents, and FastAPI endpoint testing.
+
+## TDD Workflow
+
+1. **RED**: Write tests that FAIL
+2. **GREEN**: Implementation makes tests PASS
+3. **REFACTOR**: Clean up while tests stay GREEN
+
+## Required Test Categories
+
+### For Workflow Steps/Actors:
+1. Graph execution with correct node transitions
+2. Error propagation through the graph
+3. Parallel step execution at same dependency level
+4. Actor streaming with emit/receive
+5. Cache hit/miss behavior (content-addressed)
+
+### For Agent Tools:
+6. Tool invocation with correct context
+7. Approval level enforcement (workspace/product/system)
+8. Error handling and graceful degradation
+
+### For Workspace Operations:
+9. File creation/deletion with atomic writes
+10. Concurrent access safety
+11. Asset library deduplication
+12. Hierarchy traversal (Workspace → Project → Experiment → Run)
+
+### For API Endpoints:
+13. CRUD operations with correct status codes
+14. Request validation (malformed input)
+15. WebSocket event streaming
+
+## Test Organization
+
+```
+tests/
+├── workflow/   → src/molexp/workflow/
+├── agent/      → src/molexp/agent/
+├── server/     → src/molexp/server/
+└── workspace/  → src/molexp/workspace/
+```
+
+Each directory has `conftest.py` for shared fixtures.
+
+## Rules
+
+- `pytest tests/` for Python, `npm test` for TypeScript
+- Coverage target: ≥80% per module
+- Use `conftest.py` fixtures, not standalone fixture files
+- Never modify tests to make them pass — fix implementation
+
+## Your Task
+
+When invoked, you:
+1. Design test cases from spec
+2. Write test code in appropriate tests/ subdirectory
+3. Include all required test categories
+4. Verify tests FAIL before implementation (RED)
+5. After implementation, verify tests PASS (GREEN)
diff --git a/.claude/skills/molexp-agent-tool/SKILL.md b/.claude/skills/molexp-agent-tool/SKILL.md
new file mode 100644
index 00000000..7c7f7557
--- /dev/null
+++ b/.claude/skills/molexp-agent-tool/SKILL.md
@@ -0,0 +1,40 @@
+---
+name: molexp-agent-tool
+description: Develop a new agent tool for molexp's PydanticAI agent system with proper approval levels.
+disable-model-invocation: true
+allowed-tools: Read, Edit, Write, Bash, Grep, Glob
+argument-hint: <tool description>
+---
+
+Develop agent tool: $ARGUMENTS
+
+## Steps
+
+1. **Read patterns**: `src/molexp/agent/tools.py` (base class + decorator), `src/molexp/agent/_pydantic_ai/workspace_tools.py` (examples), `src/molexp/agent/policy.py` (approval).
+
+2. **Choose style**:
+   ```python
+   # Decorator (simple)
+   @agent_tool(level="workspace", requires_approval=False)
+   async def my_tool(ctx: ToolContext, path: str) -> str: ...
+
+   # Class (complex, stateful)
+   class MyTool(Tool):
+       name = "my_tool"
+       level = "product"
+       requires_approval = True
+       async def call(self, ctx: ToolContext, **kwargs) -> dict: ...
+   ```
+
+3. **Set approval level**:
+   - `workspace` — read-only / low-risk, auto-approved
+   - `product` — creates/modifies data, may need approval
+   - `system` — affects system, always needs approval
+
+4. **Implement**: Tools get `ToolContext` (workspace, run, services). Return Pydantic models. Handle errors gracefully.
+
+5. **Register**: Add to `src/molexp/agent/_pydantic_ai/workspace_tools.py` or new module in `_pydantic_ai/`. Export from `src/molexp/agent/__init__.py` if public.
+
+6. **Test** in `tests/agent/`: tool execution, approval requirements, error handling.
+
+7. **Verify**: `pytest tests/agent/`
diff --git a/.claude/skills/molexp-api/SKILL.md b/.claude/skills/molexp-api/SKILL.md
new file mode 100644
index 00000000..3361fcc9
--- /dev/null
+++ b/.claude/skills/molexp-api/SKILL.md
@@ -0,0 +1,46 @@
+---
+name: molexp-api
+description: Develop a new API endpoint or modify an existing one — route, schema, client regen, mock handler.
+disable-model-invocation: true
+allowed-tools: Read, Edit, Write, Bash, Grep, Glob
+argument-hint: <endpoint description>
+---
+
+Develop API endpoint: $ARGUMENTS
+
+## Steps
+
+1. **Read conventions**: Check existing routes in `src/molexp/server/routes/` and schemas in `src/molexp/server/schemas/`.
+
+2. **Define schemas** in `src/molexp/server/schemas/requests.py` and `responses.py`:
+   - Request: `BaseModel` with strict types
+   - Response: Use `EntityMixin` (id) and `TimestampMixin` (created_at) where appropriate
+
+3. **Implement route** in `src/molexp/server/routes/<module>.py`:
+   - Use `Depends(get_workspace)` for workspace access
+   - Keep handlers thin — delegate to workspace/workflow/agent layer
+   - Register router in `routes/__init__.py`
+
+4. **Write tests** in `tests/server/`:
+   - Route with `TestClient`
+   - Request validation (invalid inputs → 400)
+   - Response schema compliance
+   - Error cases (404, 500)
+
+5. **Regenerate frontend client**:
+   ```bash
+   cd ui && npm run generate:api
+   ```
+
+6. **Add MSW mock** in `ui/mocks/handlers/`:
+   - Handler matching the endpoint
+   - Register in `ui/mocks/handlers/index.ts`
+
+7. **Verify**: `pytest tests/server/` and `cd ui && npx tsc --noEmit`
+
+## Conventions
+
+- All routes under `/api` prefix
+- Plural nouns for collections (`/api/projects`)
+- Pydantic schemas for all request/response bodies
+- SSE for streaming (see `routes/agent.py` pattern)
diff --git a/.claude/skills/molexp-design/SKILL.md b/.claude/skills/molexp-design/SKILL.md
new file mode 100644
index 00000000..56223d94
--- /dev/null
+++ b/.claude/skills/molexp-design/SKILL.md
@@ -0,0 +1,63 @@
+---
+name: molexp-design
+description: Audit or polish molexp frontend for visual quality, information density, and design system consistency. Use for UI polish passes, dense-layout redesigns, or before shipping a UI feature. Delegates to the molexp-designer agent for review and applies fixes.
+disable-model-invocation: true
+allowed-tools: Read, Edit, Write, Bash, Grep, Glob, Agent
+argument-hint: <renderer, panel, or "diff" to audit current changes>
+---
+
+Audit or polish UI for: $ARGUMENTS
+
+If $ARGUMENTS is empty or `diff`, audit files from `git diff --name-only HEAD -- 'ui/**'`.
+
+## Phase 1: Ground Truth
+
+Read the design stack to anchor the review:
+
+1. `ui/src/styles/tailwind.css` — current theme tokens (zinc base, semantic `--color-*`)
+2. `ui/src/components/ui/` — available primitives; never re-roll these
+3. Two or three existing renderers in `ui/src/app/renderers/` — for consistency patterns
+4. `ui/src/app/layout/` and `ui/src/app/panels/` — three-panel conventions
+
+## Phase 2: Review
+
+Invoke the `molexp-designer` agent on the target(s). Its output is the authoritative review.
+
+- If $ARGUMENTS names a renderer/file, pass that path.
+- If reviewing a diff, pass the file list from `git diff`.
+
+Wait for its ✅/⚠️/❌ report across the 10 dimensions (density, hierarchy, tokens, spacing, interaction, states, a11y, icons, responsive, consistency).
+
+## Phase 3: Apply Fixes
+
+Work through the report by severity:
+
+1. CRITICAL first: a11y blockers, token violations, contrast failures.
+2. HIGH next: density regressions, missing empty/error states, inconsistency with neighbors.
+3. MEDIUM when cheap: spacing drift, icon size fixes, missing hover.
+4. LOW only if the user requests polish.
+
+For each fix:
+- Prefer a minimal diff using existing primitives (`Card`, `Badge`, `Tooltip`, `ScrollArea`, `Button`, …)
+- Replace raw colors with semantic tokens (`bg-background`, `text-muted-foreground`, `border-border`)
+- Collapse wasteful spacing (`py-8` → `py-2`, `text-2xl` → `text-sm font-semibold`)
+- Ensure hover/selected/focus states on every interactive row
+- Ensure loading (`<Skeleton>`), empty, and error branches exist
+
+## Phase 4: Verify
+
+```bash
+cd ui && npx tsc --noEmit
+cd ui && npm test
+cd ui && npm run dev:mock   # visually confirm when a dev server is expected
+```
+
+If visual verification is not possible in this environment, say so explicitly — do not claim the change "looks good" without seeing it.
+
+## Rules
+
+- Do not edit `ui/src/api/generated/`.
+- Do not invent new design tokens — add to `tailwind.css` only if the user confirms a theme change.
+- Do not introduce a new UI primitive if a suitable one exists in `components/ui/`.
+- Density first: if a change makes the layout sparser without a user-visible reason, reject it.
+- This skill is for **visual quality**. For behavior changes, state reshaping, or new features, use `/molexp-ui` instead.
diff --git a/.claude/skills/molexp-impl/SKILL.md b/.claude/skills/molexp-impl/SKILL.md
new file mode 100644
index 00000000..ab76c82b
--- /dev/null
+++ b/.claude/skills/molexp-impl/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: molexp-impl
+description: Full feature implementation for molexp — use when implementing a feature, fixing a bug, or making a significant code change that spans multiple layers.
+disable-model-invocation: true
+allowed-tools: Read, Edit, Write, Bash, Grep, Glob, Agent
+argument-hint: <feature description or spec file path>
+---
+
+Implement $ARGUMENTS in the molexp project.
+
+**Execution discipline**: Before writing any code, enter **Plan Mode** to lay out the full plan, then create **Tasks** for each phase below. Update task status as work progresses (`in_progress` → `completed`). This enforces a structured, auditable workflow — the agent must not skip phases or jump ahead without completing prior tasks.
+
+## Phase 1: Understand
+
+Read the relevant source files to understand what exists. If `$ARGUMENTS` is a file path, read it as a spec. Determine which layers are affected:
+
+- `src/molexp/workspace/` — data models, file-system state
+- `src/molexp/workflow/` — task graph, steps, runtime
+- `src/molexp/agent/` — PydanticAI agent tools/service
+- `src/molexp/server/` — FastAPI routes, schemas
+- `ui/src/` — React renderers, state, components
+
+Create an implementation plan with discrete steps. Present it and wait for confirmation.
+
+## Phase 2: Implement (TDD)
+
+For each step:
+
+1. Write test in `tests/<module>/` — must FAIL first
+2. Implement minimal code to pass — files < 800 lines, functions < 50 lines
+3. Refactor — no duplication, immutable patterns
+
+## Phase 3: Cross-layer wiring
+
+If multiple layers changed, wire them bottom-up:
+
+1. Workspace/Workflow core logic
+2. Server routes + schemas in `src/molexp/server/schemas/` and `routes/`
+3. Register new route in `routes/__init__.py`
+4. Regenerate TS client: `cd ui && npm run generate:api`
+5. UI renderers in `ui/src/app/renderers/`, register in `registry.ts`
+6. MSW mocks in `ui/mocks/handlers/`
+
+## Phase 4: Verify
+
+Run `pytest tests/<module>/` for each affected module. Run `cd ui && npx tsc --noEmit` if UI changed. Review the diff for layer violations, missing tests, mutation, hardcoded values.
+
+## Rules
+
+- Module = Feature. No standalone micro-utility files.
+- All imports at file top. No inline/deferred imports.
+- `_pydantic_graph/` and `_pydantic_ai/` are private — never import from outside parent package.
+- `ui/src/api/generated/` is auto-generated — never edit manually.
+- Atomic JSON writes: temp-file + `os.rename`.
+- Immutable: return new objects, never mutate.
diff --git a/.claude/skills/molexp-review/SKILL.md b/.claude/skills/molexp-review/SKILL.md
new file mode 100644
index 00000000..480866c0
--- /dev/null
+++ b/.claude/skills/molexp-review/SKILL.md
@@ -0,0 +1,60 @@
+---
+name: molexp-review
+description: Comprehensive code review aggregating architecture, performance, documentation, async safety, and UI design checks. Use after writing code or during PR review.
+argument-hint: "[path or module]"
+user-invocable: true
+---
+
+Review code for: $ARGUMENTS
+
+If no path given, review all files modified in `git diff --name-only HEAD`.
+
+**Invoke all dimensions in parallel:**
+
+1. **Architecture** → invoke `/molexp-spec` validation checks (layer compliance L1-L5)
+2. **Performance** → check async/I/O anti-patterns
+3. **Documentation** → check docstring completeness
+4. **Async & System Safety**:
+   - No blocking calls in async context (sync I/O, time.sleep)
+   - Concurrency: proper locking, no race conditions on shared state
+   - Caching correctness: cache invalidation on mutation
+   - Atomic persistence: temp-file + os.rename pattern
+   - N+1 patterns: batch queries instead of per-item
+   - WebSocket: proper cleanup on disconnect
+   - Private modules: no imports from `_pydantic_graph/` or `_pydantic_ai/`
+   - Generated code: `ui/src/api/generated/` never manually edited
+5. **Code Quality** (inline):
+   - Functions < 50 lines, files < 800 lines
+   - No deep nesting (> 4 levels)
+   - No hardcoded magic numbers
+   - Type annotations on all public APIs
+   - Google-style docstrings (Python), JSDoc (TypeScript)
+   - Module = Feature organization
+6. **Immutability** (inline):
+   - No mutation of input objects
+   - Pydantic models use model_copy() not direct assignment
+   - New dicts/lists for transformed data
+7. **UI Design** (only if `ui/` files changed) → delegate to `molexp-designer` agent:
+   - Information density, hierarchy, token discipline
+   - Loading / empty / error states
+   - Accessibility, keyboard order, contrast
+   - Consistency with other renderers
+
+**Severity levels**:
+- CRITICAL — must fix (architecture violations, async safety)
+- HIGH — should fix (missing tests, performance issues)
+- MEDIUM — fix when possible (style, documentation gaps)
+- LOW — nice to have
+
+**Output**: Merged report:
+```
+CODE REVIEW: <path>
+ARCHITECTURE: ✅/❌ per check
+PERFORMANCE: ✅/⚠️ per check
+DOCUMENTATION: ✅/⚠️ per check
+ASYNC & SYSTEM SAFETY: ✅/❌ per check
+CODE QUALITY: ✅/⚠️ per check
+IMMUTABILITY: ✅/❌ per check
+UI DESIGN: ✅/⚠️ per check (only if ui/ touched)
+SUMMARY: N CRITICAL, N HIGH, N MEDIUM, N LOW
+```
diff --git a/.claude/skills/molexp-spec/SKILL.md b/.claude/skills/molexp-spec/SKILL.md
new file mode 100644
index 00000000..3037fa35
--- /dev/null
+++ b/.claude/skills/molexp-spec/SKILL.md
@@ -0,0 +1,51 @@
+---
+name: molexp-spec
+description: Convert a natural language requirement into a structured technical spec for molexp.
+disable-model-invocation: true
+allowed-tools: Read, Grep, Glob, Agent
+argument-hint: <natural language requirement>
+---
+
+Convert this requirement into a technical spec: $ARGUMENTS
+
+## Process
+
+1. **Analyze**: Read relevant source files to understand current state. Identify which layers are involved (workspace, workflow, agent, server, UI).
+
+2. **Generate spec** in this format:
+
+```markdown
+# Spec: <Feature Name>
+
+## Summary
+One paragraph: what and why.
+
+## Affected Layers
+- [ ] workspace — data models, persistence
+- [ ] workflow — steps, runtime, caching
+- [ ] agent — tools, service, policy
+- [ ] server — routes, schemas
+- [ ] UI — renderers, state, components
+
+## Data Models
+New/modified Pydantic models with fields and types.
+
+## API Changes
+| Method | Path | Request | Response | Breaking? |
+
+## Workflow Changes
+New steps/actors, modified specs, dependency changes.
+
+## UI Changes
+New renderers, state changes, mock handlers.
+
+## Test Plan
+Per-module unit tests + cross-layer integration tests.
+
+## Open Questions
+Decisions that need user input.
+```
+
+3. **Validate**: Check for layer violations, Module=Feature compliance, backwards compatibility.
+
+4. **Save**: On approval, write to `docs/developer/<feature-name>-spec.md`.
diff --git a/.claude/skills/molexp-step/SKILL.md b/.claude/skills/molexp-step/SKILL.md
new file mode 100644
index 00000000..912dee19
--- /dev/null
+++ b/.claude/skills/molexp-step/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: molexp-step
+description: Develop a new workflow Step (batch) or Actor (streaming) for molexp's pydantic-graph workflow system.
+disable-model-invocation: true
+allowed-tools: Read, Edit, Write, Bash, Grep, Glob
+argument-hint: <step/actor description>
+---
+
+Develop workflow step: $ARGUMENTS
+
+## Steps
+
+1. **Choose type**:
+   - `Step` (batch) — runs once, returns result: `async def execute(ctx) -> OutputT`
+   - `Actor` (streaming) — runs continuously, yields: `async def run(ctx) -> AsyncIterator[OutputT]`
+
+2. **Define types**: `OutputT` as Pydantic model (never raw dict). `InputT` from upstream. `StateT` for shared state. `DepsT` for injected deps.
+
+3. **Implement** using context:
+   - `ctx.state` — shared mutable workflow state
+   - `ctx.deps` — injected (workspace, run, services)
+   - `ctx.inputs` — typed upstream output
+   - Actors: `await ctx.receive()` / `await ctx.emit(channel, msg)`
+
+4. **Integrate** via functional or OOP DSL:
+   ```python
+   # Functional
+   @wf.step(depends_on=["upstream"])
+   async def my_step(ctx: StepContext[S, D, InputT]) -> OutputT: ...
+
+   # OOP
+   wf.add(MyStep(), depends_on=["upstream"])
+   ```
+
+5. **Test** in `tests/workflow/`: isolate step first, then test in workflow spec.
+
+6. **Verify**: `pytest tests/workflow/`
+
+## Rules
+
+- Return annotation determines execution type — no explicit flags
+- Same-level steps parallelize automatically
+- `parallel_map()` / `join()` for explicit fan-out/fan-in
+- Never import from `_pydantic_graph/` directly
diff --git a/.claude/skills/molexp-test/SKILL.md b/.claude/skills/molexp-test/SKILL.md
new file mode 100644
index 00000000..01e06520
--- /dev/null
+++ b/.claude/skills/molexp-test/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: molexp-test
+description: User-invoked TDD workflow to write or improve tests for molexp modules with coverage analysis. Orchestrates the process; delegates test authoring to the molexp-tester agent when useful.
+disable-model-invocation: true
+allowed-tools: Read, Edit, Write, Bash, Grep, Glob
+argument-hint: <module or feature to test>
+---
+
+Write tests for: $ARGUMENTS
+
+## Steps
+
+1. **Identify scope**: Read source code and existing tests. Check `conftest.py` for fixtures.
+
+2. **Organize**: Tests mirror source:
+   ```
+   tests/agent/     → src/molexp/agent/
+   tests/server/    → src/molexp/server/
+   tests/workflow/  → src/molexp/workflow/
+   tests/workspace/ → src/molexp/workspace/
+   ```
+   Shared fixtures in `tests/<module>/conftest.py`.
+
+3. **TDD cycle** for each function/class:
+   - Write test → FAIL (RED)
+   - Implement → PASS (GREEN)
+   - Refactor (IMPROVE)
+
+4. **Backend patterns**:
+   ```python
+   # Workspace: use tmp_path, not mocks
+   def test_run_persists(tmp_path):
+       ws = Workspace(root=tmp_path)
+       ws.materialize()
+
+   # Server: use TestClient
+   def test_endpoint(client: TestClient):
+       resp = client.post("/api/projects", json={"name": "test"})
+       assert resp.status_code == 201
+
+   # Workflow: test step in isolation, then in spec
+   async def test_step():
+       result = await step.execute(ctx)
+   ```
+
+5. **Frontend**: Vitest, fixtures in `ui/src/__fixtures__/`.
+
+6. **Coverage**: `pytest tests/<module>/ --cov=src/molexp/<module> --cov-report=term-missing` — target 80%+.
+
+## Rules
+
+- Don't mock filesystem in integration tests — use `tmp_path`
+- Don't test `_pydantic_graph/` internals — test through public API
+- Don't duplicate fixtures — use `conftest.py`
+- Tests must be order-independent
diff --git a/.claude/skills/molexp-ui/SKILL.md b/.claude/skills/molexp-ui/SKILL.md
new file mode 100644
index 00000000..f8ad266a
--- /dev/null
+++ b/.claude/skills/molexp-ui/SKILL.md
@@ -0,0 +1,41 @@
+---
+name: molexp-ui
+description: Develop a frontend component, renderer, or UI feature for molexp's React UI — focuses on mechanics (state wiring, registration, mocks). For visual polish or design audits use /molexp-design.
+disable-model-invocation: true
+allowed-tools: Read, Edit, Write, Bash, Grep, Glob, Agent
+argument-hint: <component or feature description>
+---
+
+Develop UI feature: $ARGUMENTS
+
+## Steps
+
+1. **Read context**: Check `ui/src/app/registry.ts` (renderer dispatch), existing renderers in `ui/src/app/renderers/`, state in `ui/src/app/state/`, generated types in `ui/src/api/generated/models/`.
+
+2. **Implement component**:
+   - Renderer → `ui/src/app/renderers/<Name>Viewer.tsx`
+   - UI primitive → `ui/src/components/ui/` (Radix-based, no business logic)
+   - Register renderer in `registerRenderers.ts` and `registry.ts`
+
+3. **Wire state**:
+   - Zustand stores: `useWorkspaceState`, `useUrlState`
+   - API calls through `ui/src/app/state/api.ts` — never call generated services directly
+   - Entity resolution: URL state → resolver → renderer
+
+4. **Mock data** (for `dev:mock` mode):
+   - Data in `ui/mocks/db/index.ts`
+   - Handler in `ui/mocks/handlers/`
+   - Register in `ui/mocks/handlers/index.ts`
+
+5. **Test**: Add `.test.ts` file, fixtures in `ui/src/__fixtures__/`
+
+6. **Verify**:
+   ```bash
+   cd ui && npx tsc --noEmit && npm test && npm run dev:mock
+   ```
+
+7. **Design pass**: invoke the `molexp-designer` agent on the changed renderer/files. Apply CRITICAL and HIGH fixes it reports (token violations, missing states, density regressions). For deeper polish, use `/molexp-design`.
+
+## Stack
+
+React 19, TypeScript strict, Rsbuild, Radix UI, `@xyflow/react` (graphs), Monaco (editor), Vitest.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..226a6bee
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,62 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+      - dev
+  pull_request:
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install tools
+        run: pip install ruff ty
+
+      - name: Ruff format
+        run: ruff format --check src/ tests/
+
+      - name: Ruff lint
+        run: ruff check src/ tests/
+
+      - name: Type check
+        run: ty check src/
+
+  test:
+    name: Test on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest tests/ -q --cov=src/molexp --cov-report=xml
+
+      - name: Upload coverage
+        if: matrix.python-version == '3.12'
+        uses: codecov/codecov-action@v4
+        with:
+          files: coverage.xml
+          fail_ci_if_error: false
diff --git a/.gitignore b/.gitignore
index 5f12af07..dd8aef3c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -185,4 +185,8 @@ psd
 thumb
 sketch
 
-openapi.json
\ No newline at end of file
+openapi.json
+
+# Compiled frontend bundle (populated by `npm run build:ui`)
+src/molexp/_webapp/*
+!src/molexp/_webapp/.gitkeep
\ No newline at end of file
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000..5ac8b3ab
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,30 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+        args: ['--unsafe']
+      - id: check-added-large-files
+        args: ['--maxkb=1024']
+      - id: check-merge-conflict
+      - id: mixed-line-ending
+      - id: check-toml
+      - id: check-json
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.12
+    hooks:
+      - id: ruff-format
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+
+  - repo: local
+    hooks:
+      - id: ty
+        name: ty (type check)
+        entry: ty check src/
+        language: system
+        types: [python]
+        pass_filenames: false
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..5b2d1cb6
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,255 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+### Backend (Python)
+
+```bash
+# Install in editable mode (no frontend build — Python-only dev loop)
+pip install -e .
+
+# Run all tests
+pytest tests/
+
+# Run specific test module
+pytest tests/workspace/test_workspace.py
+
+# Run single test
+pytest tests/workspace/test_workspace.py::test_workspace_creation
+
+# Start server (serves bundled UI if src/molexp/_webapp/ is populated, otherwise API-only)
+molexp serve --workspace /path/to/workspace --port 8000
+
+# Initialize a workspace
+molexp init [path]
+
+# Release: build frontend into src/molexp/_webapp/, then build the wheel
+npm run build:ui
+python -m build --wheel
+```
+
+### Frontend (TypeScript/React)
+
+```bash
+cd ui
+
+# Dev server (localhost:5173, requires running backend)
+npm run dev
+
+# Dev with mock API (no backend needed)
+npm run dev:mock
+
+# Production build
+npm run build
+
+# Run frontend tests
+npm test
+
+# Regenerate TypeScript API client from openapi.json
+npm run generate:api
+```
+
+### After changing the FastAPI backend
+
+1. Regenerate `openapi.json` (start server, fetch `/api/openapi.json`)
+2. Regenerate the TypeScript client: `cd ui && npm run generate:api`
+3. Update MSW mock handlers in `ui/mocks/handlers/` if new endpoints added
+
+## Architecture
+
+molexp is a workflow-and-agent platform for research experiment management, built on pydantic-graph and PydanticAI.
+
+```
+WorkflowSpec → pydantic-graph Compiler → Runtime → Workspace → FastAPI → React UI
+                                                       ↑
+                                            AgentService (PydanticAI)
+```
+
+### Five Core Layers
+
+#### 1. Workflow Layer (`src/molexp/workflow/`)
+
+Two equivalent APIs for defining task graphs:
+
+**Functional DSL** (decorator-based):
+```python
+wf = workflow(name="pipeline")
+
+@wf.step
+async def fetch(ctx: StepContext[State, Deps, None]) -> FetchResult: ...
+
+@wf.step(depends_on=["fetch"])
+async def process(ctx: StepContext[State, Deps, FetchResult]) -> ProcessResult: ...
+
+spec = wf.build()
+result = await spec.execute(run=run)
+```
+
+**OOP DSL** (builder-based):
+```python
+wf = WorkflowBuilder(name="pipeline").add(FetchStep()).add(ProcessStep(), depends_on=["fetch"]).build()
+result = await wf.execute(run=run)
+```
+
+Key abstractions:
+- `Step` — Batch execution (`async def execute(ctx) -> OutputT`)
+- `Actor` — Streaming execution (`async def run(ctx) -> AsyncIterator[OutputT]`)
+- `StepContext` / `ActorContext` — Typed context with state, deps, inputs
+- `WorkflowSpec` — Compiled spec with deterministic `workflow_id` (topology hash)
+- `WorkflowRuntime` — Abstract runtime; `GraphWorkflowRuntime` backed by pydantic-graph
+
+Internal `_pydantic_graph/` compiles specs into pydantic-graph IR with topological levels for automatic parallelization. Never import from `_pydantic_graph/` directly.
+
+Supporting modules: `cache.py` (LRU content-addressed), `persistence.py` (run store adapter), `snapshot.py` (AST-normalized code hashing).
+
+#### 2. Agent Layer (`src/molexp/agent/`)
+
+Goal-driven autonomous execution built on PydanticAI. Public API:
+
+```python
+service = AgentService.from_workspace("./lab")
+session = await service.run(Goal(description="...", constraints=[...]))
+```
+
+- `AgentService` — Entry point, creates sessions from workspace
+- `AgentRuntime` — Abstract runtime (PydanticAI implementation in `_pydantic_ai/`)
+- `Tool` / `@agent_tool` — Tool definitions with approval levels
+- `ApprovalPolicy` — Glob-pattern-based tool approval control
+- Session events: `PlanCreatedEvent`, `ToolCallEvent`, `ObservationEvent`, etc.
+
+Internal `_pydantic_ai/` handles PydanticAI integration. Never import directly.
+
+#### 3. Workspace Layer (`src/molexp/workspace/`)
+
+File-system-backed hierarchical state: `Workspace → Project → Experiment → Run`
+
+- Each level owns an `AssetLibrary` (content-addressed, deduplication)
+- `RunContext` manages execution lifecycle (enter → execute → exit with status)
+- `ParamSpace` (`GridSpace`, `UniformSpace`) for parameter sweeps
+- `ResumePolicy` protocol for resumable execution
+- All metadata writes are atomic (temp-file + `os.rename`)
+- Constructors are side-effect-free; call `materialize()` to create dirs/files
+
+#### 4. Server Layer (`src/molexp/server/`)
+
+FastAPI app, all routes under `/api`:
+
+| Route module | Endpoints |
+|---|---|
+| `agent.py` | Session CRUD, SSE event streaming, approval |
+| `project.py` | Project CRUD |
+| `experiment.py` | Experiment CRUD |
+| `run.py` | Run CRUD |
+| `workspace.py` | Workspace open/list/folders |
+| `execution.py` | Execution planning/status |
+| `registry.py` | Available task types |
+| `asset.py` | Asset management |
+
+- `dependencies.py` — FastAPI DI: `get_workspace()`, `get_settings()`
+- `manager.py` — `ServerManager` for lifecycle (start/stop/status/logs)
+- Production: serves SPA from `static_dir`; Dev: API-only + CORS for localhost:5173
+
+#### 5. UI Layer (`ui/src/`)
+
+React 19 + Rsbuild, three-panel layout:
+
+- **Left**: Navigation tree (projects, experiments, runs)
+- **Center**: Content viewer (dispatched by entity type via `registry.ts`)
+- **Right**: Inspector/metadata panel
+
+Key patterns:
+- `registry.ts` — Maps entity types to renderer components
+- `state/useWorkspaceState.ts` — Zustand store for workspace state
+- `state/useUrlState.ts` — URL-based routing state
+- `state/api.ts` — Wraps auto-generated OpenAPI client
+- `api/generated/` — **Never edit manually**; regenerate with `npm run generate:api`
+- `mocks/handlers/` — MSW handlers for `dev:mock` mode; keep in sync with API changes
+- `resolvers/` — Entity resolution for rendering dispatch
+
+Component library preference:
+- Prefer **shadcn/ui** components when implementing UI features.
+- When a shadcn component does not fit, **document the reason in the PR description**.
+
+### Packaging & Frontend Serving
+
+The React frontend is **compiled ahead of time by npm** and bundled inside the Python package — matching the `molvis` release workflow. `pip install` / `python -m build` **never** invokes npm.
+
+```
+ui/src/  →  (npm run build:ui)  →  src/molexp/_webapp/  →  (hatchling)  →  wheel
+```
+
+- **Root `package.json`** exposes `npm run build:ui`, which builds the `molexp-ui` workspace and copies `ui/dist/.` into `src/molexp/_webapp/`
+- **`pyproject.toml`** uses `hatchling` and declares `[tool.hatch.build] artifacts = ["src/molexp/_webapp/**"]` so the wheel ships the bundle
+- **`src/molexp/_webapp/`** is gitignored (except `.gitkeep`); it is populated on demand by `npm run build:ui`
+- **Runtime**: `create_app()` uses `importlib.resources.files("molexp") / "_webapp"` to locate the bundled assets. If empty, the server runs API-only.
+- **Release**: `npm run build:ui && python -m build --wheel`
+- **Dev mode**: Run backend (`molexp serve --port 8000`) and frontend (`npm run dev` from repo root, or `cd ui && npm run dev`) separately
+- **Production** (`molexp serve`): serves API + bundled SPA from the installed package
+
+### Key Patterns
+
+- **Topology-driven parallelism**: Steps grouped into levels by dependency graph; same-level steps run in parallel automatically
+- **Content-addressed caching**: `TaskSnapshot` uses AST-normalized code hash + config hash; whitespace/comment changes don't invalidate cache
+- **Atomic persistence**: All JSON writes use temp-file + `os.rename` for crash safety
+- **Internal convention**: Prefixed `_pydantic_graph/` and `_pydantic_ai/` are private implementation details; public API is the parent package's `__init__.py`
+
+### Adding a New Workflow Step
+
+1. Subclass `Step` (batch) or `Actor` (streaming) in appropriate module
+2. Implement `execute()` / `run()` with typed return annotation
+3. Add to workflow via functional DSL (`@wf.step`) or OOP builder (`.add()`)
+4. Compiler auto-detects execution type from return annotation
+
+### Adding a New API Route
+
+1. Add route handler in `src/molexp/server/routes/<module>.py`
+2. Register router in `src/molexp/server/routes/__init__.py`
+3. Add request/response Pydantic schemas to `src/molexp/server/schemas/`
+4. Regenerate openapi.json and TS client: `cd ui && npm run generate:api`
+5. Add MSW mock handler in `ui/mocks/handlers/` for `dev:mock`
+
+### Adding a New UI Renderer
+
+1. Create component in `ui/src/app/renderers/<Name>Viewer.tsx`
+2. Register in `ui/src/app/renderers/registerRenderers.ts`
+3. Add entity type mapping in `ui/src/app/registry.ts`
+4. Add test fixture in `ui/src/__fixtures__/`
+
+### Test Organization
+
+Tests mirror source structure:
+```
+tests/
+├── agent/          → src/molexp/agent/
+├── server/         → src/molexp/server/
+├── workflow/       → src/molexp/workflow/
+└── workspace/      → src/molexp/workspace/
+```
+
+Each test directory has `conftest.py` for shared fixtures. Use `conftest.py` at directory level, not standalone fixture files.
+
+## Skills (`.claude/skills/`)
+
+| Skill | Trigger | Purpose |
+|---|---|---|
+| `/molexp-impl` | User | Full feature implementation (plan → TDD → cross-layer wiring → verify) |
+| `/molexp-spec` | User | Natural language → structured technical spec |
+| `/molexp-api` | User | API endpoint (route + schema + client regen + MSW mock) |
+| `/molexp-ui` | User | Frontend mechanics (renderer + state + mock + test) — invokes `molexp-designer` for post-impl polish |
+| `/molexp-design` | User | Frontend visual/UX polish: info density, design-system tokens, a11y, empty/error states |
+| `/molexp-step` | User | Workflow Step/Actor development |
+| `/molexp-test` | User | TDD testing with coverage analysis |
+| `/molexp-review` | Auto/User | Architecture + performance + UI design review (layer compliance, async safety, caching, I/O, concurrency, design system) |
+| `/molexp-agent-tool` | User | PydanticAI agent tool development |
+
+### Agents (delegated, not user-invoked)
+
+| Agent | Axis |
+|---|---|
+| `molexp-architect` | 5-layer compliance, module boundaries |
+| `molexp-optimizer` | Async, I/O, serialization, React perf |
+| `molexp-tester` | Test authoring (RED/GREEN/REFACTOR) |
+| `molexp-documenter` | Google-style docstrings, JSDoc, OpenAPI descriptions |
+| `molexp-designer` | UI visual quality, info density, tokens, a11y |
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..3e83c7d4
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, molcrafts
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/README.md b/README.md
index 85e5b9a0..951659e4 100644
--- a/README.md
+++ b/README.md
@@ -1,44 +1,64 @@
 # molexp
 
-molexp is a tiny yet fully-typed task-graph framework built on top of Pydantic. It contains a
-pure functional task abstraction, a static compiler that produces deterministic graph orders, a
-runtime engine, and a tiny DSL for common data-flow patterns. This repository is intentionally
-minimal to highlight how each layer works without hidden magic.
+molexp is a workflow-and-agent platform for research experiment management. It provides a typed task-graph framework, a Project-Experiment-Run workspace hierarchy, content-addressed asset storage, and a FastAPI server with React UI.
 
 ```
-+-----------+       +-----------+       +---------+
-|   Task    |  -->  | Compiler  |  -->  | Engine  |
-+-----------+       +-----------+       +---------+
-        ^                  |                  |
-        |                  v                  v
-        +----------- DSL abstractions --------+
+WorkflowSpec → Runtime → Workspace → FastAPI → React UI
+                             ↑
+                      AgentService (PydanticAI)
 ```
 
 ## Features
 
-- **Task Graph Framework**: Pure functional task abstraction with deterministic compilation
+- **Workflow Layer**: DAG-based task graphs with automatic parallelization
 - **Project-Experiment-Run Architecture**: Scientific workflow organization with full reproducibility
 - **Asset Management**: Content-addressable storage with automatic deduplication
-- **CLI Tools**: Command-line interface for workspace and workflow management
-- **Type Safety**: Full Pydantic v2 integration for data validation
+- **Agent Layer**: Goal-driven autonomous execution built on PydanticAI
+- **CLI + Web UI**: Command-line interface and React-based experiment browser
 
-## Quick Example: Task Graph
+## Quick Example: Workflow
+
+**Functional DSL (decorator-based):**
+
+```python
+from molexp.workflow import workflow, TaskContext
+
+wf = workflow(name="data-pipeline")
+
+@wf.task
+async def fetch(ctx: TaskContext) -> list[float]:
+    return [1.0, 2.0, 3.0]
+
+@wf.task(depends_on=["fetch"])
+async def process(ctx: TaskContext) -> float:
+    if ctx.dry_run:
+        return 0.0
+    return sum(ctx.inputs)
+
+spec = wf.build()
+result = await spec.execute()
+```
+
+**OOP builder (subclass-based):**
 
 ```python
-from molexp.task_base import Task, EmptyConfig
-from molexp.engine import TaskEngine
+from molexp.workflow import Task, WorkflowBuilder, TaskContext
 
-class MultiplyTask(Task[EmptyConfig, int]):
-    cfg_model = EmptyConfig
-    out_model = None
+class FetchTask(Task):
+    async def execute(self, ctx: TaskContext) -> list[float]:
+        return [1.0, 2.0, 3.0]
 
-    def forward(self, value: int, cfg: EmptyConfig) -> int:
-        return value * 2
+class ProcessTask(Task):
+    async def execute(self, ctx: TaskContext) -> float:
+        return sum(ctx.inputs)
 
-mult = MultiplyTask(name="multiply")
-engine = TaskEngine()
-result = engine.run(mult)
-print(result)
+spec = (
+    WorkflowBuilder(name="data-pipeline")
+    .add(FetchTask())
+    .add(ProcessTask(), depends_on=["fetch"])
+    .build()
+)
+result = await spec.execute()
 ```
 
 ## Project-Experiment-Run Architecture
@@ -50,76 +70,57 @@ molexp provides a complete organization system for scientific workflows:
 - **Run**: Single execution instance with full reproducibility
 - **Asset**: Reusable data artifacts with content-based deduplication
 
-### CLI Usage
-
-```bash
-# Initialize workspace
-molexp init
-
-# Create project
-molexp project create my-project --name "My Research Project"
-
-# Create experiment
-molexp experiment create my-project exp-1 \
-  --name "Parameter Sweep" \
-  --workflow workflow.py
-
-# List runs
-molexp run list my-project exp-1
-
-# View assets
-molexp asset list
-```
-
 ### Python API
 
 ```python
 from molexp.workspace import Workspace
 
-# Create workspace
-workspace = Workspace.from_env()
+workspace = Workspace.from_path("./lab")
 
-# Create project (ID auto-generated from name)
-project = workspace.create_project(
-    name="My Project",
-    description="Research project description"
-)
+# Hierarchical API: workspace → project → experiment → run
+project = workspace.create_project(name="My Project")
+experiment = project.create_experiment(name="Param Sweep")
+run = experiment.create_run(parameters={"lr": 0.01})
 
-# Create experiment through project (hierarchical API)
-experiment = project.create_experiment(
-    name="Experiment 1",
-    workflow_source="workflow.py"
-)
-
-# Create run through experiment (hierarchical API)
-run = experiment.create_run(
-    parameters={"param": 1.0},
-    workflow_file="workflow.py"
-)
-
-# Use hierarchical asset libraries
-# Workspace-level assets (global)
+# Scoped asset libraries at every level
 workspace.assets.create_asset("bert_model", "/models/bert.pt")
-
-# Project-level assets (shared within project)
 project.assets.create_asset("dataset", "/data/qm9.tar.bz2")
-
-# Experiment-level assets (shared within experiment)
 experiment.assets.create_asset("features", "/data/features.h5")
-
-# Run-level assets (specific to this run)
 run.assets.create_asset("output", "/outputs/results.txt")
 ```
 
+### CLI Usage
+
+```bash
+# Start server (hot-reload dev mode)
+molexp serve --dev
+
+# Execute a workflow in dry-run mode
+molexp run train.py --dry-run
+
+# Initialize a workspace
+molexp init [path]
+```
+
 ## Installation
 
 ```bash
 pip install -e .
 ```
 
+Optional extras:
+
+```bash
+pip install -e ".[workflow]"   # pydantic-graph execution backend
+pip install -e ".[agent]"      # PydanticAI agent layer
+pip install -e ".[remote]"     # Remote/HPC execution
+pip install -e ".[dev]"        # Development tools
+```
+
 ## Documentation
 
-See the [docs](./docs/README.md) for an in-depth tour of the architecture, compiler, engine, and DSL
-usage.
+See the [docs](./docs/index.md) for an in-depth tour of the architecture, workflow layer, workspace, and agent integration.
+
+## License
 
-See [examples/project_experiment_run_example.py](./examples/project_experiment_run_example.py) for a complete example of the Project-Experiment-Run workflow.
+BSD 3-Clause License — see [LICENSE](./LICENSE) for details.
diff --git a/docs/developer/architecture-convergence-spec-zh.md b/docs/developer/architecture-convergence-spec-zh.md
new file mode 100644
index 00000000..53985f5c
--- /dev/null
+++ b/docs/developer/architecture-convergence-spec-zh.md
@@ -0,0 +1,391 @@
+# Molexp 架构收敛与易用性修复 Spec
+
+> 状态：Draft v1
+> 日期：2026-04-10
+> 范围：`workflow` / `workspace` / `server` / `agent` 公共模型、API 契约、文档与可用性
+> 目标：把当前“多套架构并存”的状态收敛为一套可解释、可运行、可测试、可文档化的产品架构
+
+实施拆分见 [architecture-convergence-work-breakdown-zh.md](./architecture-convergence-work-breakdown-zh.md)。
+
+---
+
+## 1. 背景
+
+当前仓库已经完成了部分新架构落地：
+
+- `workflow` 层以 `WorkflowSpec` / `Step` / `WorkflowRuntime` 为中心
+- `agent` 层以 `AgentService` / `AgentRuntime` / `PydanticAI` 封装为方向
+- `workspace` 层仍承担 `Workspace / Project / Experiment / Run / Asset` 产品语义
+
+但仓库的公共表面并未完成收敛，导致以下现象同时存在：
+
+- README、Quick Start、Core 文档仍在描述旧 `Task / IR / Engine` 架构
+- 新旧 import path 在文档中混用，且大量路径已不存在
+- server 请求模型、响应模型、核心领域模型互相不一致
+- 部分路由与核心对象的方法签名不匹配
+- 顶层 import 会隐式拉起远程执行基础设施
+- 多个“还未完成”的能力以 stub 或伪成功形式暴露给用户
+
+这不是单点 bug，而是产品架构边界没有收口。
+
+---
+
+## 2. 问题定义
+
+### 2.1 架构问题
+
+1. 没有唯一公共模型
+2. 领域模型与接口契约断裂
+3. workspace 持久化存在双重真相源
+4. 可选基础设施依赖污染默认导入路径
+
+### 2.2 易用性问题
+
+1. 首屏文档不可运行
+2. API 文档不能代表真实行为
+3. 不完整能力以“看起来可用”的形式暴露
+4. 用户无法判断什么是正式支持，什么是迁移残留
+
+---
+
+## 3. 设计目标
+
+### 3.1 产品目标
+
+- 用户只面对一套 Molexp 公共模型
+- README、Quick Start、Python API、HTTP API、测试样例描述同一套行为
+- 本地 workspace/server 使用场景不依赖远程执行或外部数据库初始化
+- 未完成能力要显式失败，不允许伪成功
+
+### 3.2 工程目标
+
+- `workflow`、`workspace`、`server`、`agent` 之间边界稳定
+- 请求模型、响应模型、领域模型一一对应
+- 文档、代码、测试由同一 contract 驱动
+- 清理旧架构残留，降低未来维护成本
+
+### 3.3 成功标准
+
+- 新用户按 README/Quick Start 可在干净环境中完成最小闭环
+- `import molexp.server.app` 不触发远程基础设施副作用
+- 所有公开路由至少有 contract test 覆盖
+- 不再出现文档存在、实现不存在的公共概念
+
+---
+
+## 4. 非目标
+
+- 不在本阶段重做 UI 视觉或前端交互
+- 不在本阶段引入复杂迁移工具链
+- 不保证对旧文档和旧 import path 的长期兼容
+- 不在本阶段扩展新的 workflow 能力面
+
+说明：
+若为降低重构风险需要短期 shim，可以存在于内部实现，但不能继续作为公共文档承诺。
+
+---
+
+## 5. 核心设计决策
+
+## 5.1 选择唯一公共模型
+
+公共架构统一为三层：
+
+1. Product Layer：`workspace / assets / project / experiment / run / server`
+2. Workflow Layer：`WorkflowSpec / WorkflowBuilder / workflow() / Step / Actor / WorkflowRuntime`
+3. Agent Layer：`Goal / AgentSession / AgentService / Tool / ApprovalPolicy`
+
+明确决策：
+
+- 旧 `Task / IR / WorkflowEngine / WorkflowCompiler` 不再作为公共文档入口
+- 若仓库内仍保留过渡性实现，必须降级为内部历史残留，不得出现在 README、Quick Start、OpenAPI 示例中
+- `molexp.__init__` 不再通过 eager import 扩散整个子系统依赖图
+
+## 5.2 Experiment 和 Run 恢复产品语义
+
+当前产品语义要求：
+
+- `Experiment` 是“可重复执行的 workflow 定义”
+- `Run` 是“某次具体执行及其快照”
+
+因此领域模型必须显式承载这些信息：
+
+- `ExperimentMetadata`
+  - `workflow_source`
+  - `workflow_type`
+  - `git_commit`
+  - `parameter_space`
+  - `description`
+  - `tags`
+  - `config`
+- `RunMetadata`
+  - `parameters`
+  - `status`
+  - `finished_at`
+  - `error`
+  - `workflow_snapshot`
+  - 必要的执行上下文引用
+
+若不准备支持这些概念，则必须同步从请求模型、响应模型、文档中删除，不能继续悬空。
+
+## 5.3 以“少参数默认可用”为 API 原则
+
+面向用户的创建接口统一采用最小必要输入：
+
+- `create_project(name, ...)`
+- `project.create_experiment(name, workflow_source, ...)`
+- `experiment.create_run(parameters, ...)`
+
+用户可选提供自定义 `id`，但不是必填。自动生成策略必须一致，且文档、CLI、HTTP API 完全一致。
+
+## 5.4 父子关系以目录结构为真相源
+
+对于 `Workspace -> Project -> Experiment -> Run`：
+
+- 子对象存在性和成员关系以目录结构加子对象 metadata 文件为真相源
+- 父 metadata 中不再维护 `projects` / `experiments` / `assets` 这类重复列表
+- 如保留索引文件，只能作为缓存，必须允许重建
+
+这样可以消除删除、恢复、手工修复时的双重真相源问题。
+
+## 5.5 可选能力必须惰性加载
+
+远程执行、HPC、外部 transfer、agent runtime 等都属于可选能力。
+
+约束如下：
+
+- 默认 import 路径不能初始化它们
+- 只有在显式调用相关能力时才加载对应依赖
+- 如果环境不满足，返回明确错误，而不是污染基础使用路径
+
+## 5.6 未完成能力必须显式 gated
+
+以下能力在未完成前必须统一策略：
+
+- agent session 执行
+- workflow plan/execution API
+- registry 查询
+- 远程执行
+
+统一行为：
+
+- 返回明确的 `501 Not Implemented` 或领域错误
+- 不返回“pending session”一类伪成功对象
+- 不在 README/Quick Start 中展示未完成能力
+
+## 5.7 文档与测试是产品表面的一部分
+
+文档和测试不是附属物，而是 contract 的一部分。
+
+必须建立三类 smoke/contract 校验：
+
+1. import smoke
+2. quick start smoke
+3. API contract smoke
+
+任一失败都视为产品表面损坏。
+
+---
+
+## 6. 目标架构
+
+## 6.1 包边界
+
+### `molexp.workspace`
+
+- 负责工作区目录模型、持久化、资产作用域、Project/Experiment/Run 生命周期
+- 不直接依赖 server、agent、远程执行基础设施
+
+### `molexp.workflow`
+
+- 负责 workflow 定义、编译适配、执行 runtime
+- 不污染顶层 import
+- 远程执行通过惰性 adapter 接入
+
+### `molexp.agent`
+
+- 负责 goal/session/tooling/approval
+- 若 runtime 不可用，服务端显式返回能力未启用
+
+### `molexp.server`
+
+- 只暴露已实现并受测试保护的 contract
+- 路由不得直接依赖“猜测式字段”或历史属性名
+
+## 6.2 顶层导入策略
+
+`molexp.__init__` 只暴露稳定符号，不执行重型导入。
+
+建议策略：
+
+- 保留 `__version__`
+- 使用 lazy import 或显式子模块导入
+- 禁止在包初始化时 import `remote`、`molq`、数据库或网络资源
+
+---
+
+## 7. Roadmap
+
+## Phase 0：冻结公共表面并建立清单
+
+目标：
+停止继续扩散新旧架构混用，先把“当前支持什么”说清楚。
+
+交付物：
+
+- 公共 API 清单
+- 历史残留 import path 清单
+- server 路由到领域模型映射清单
+- README / docs / tests 的冲突矩阵
+
+退出条件：
+
+- 每个公开入口都标记为 `supported`、`internal`、`remove`
+- 未完成能力全部标注 gating 策略
+
+## Phase 1：公共 API 收敛
+
+目标：
+只保留一套对外叙事，移除旧架构文档入口。
+
+交付物：
+
+- README 改写到新公共模型
+- Quick Start 改写为可运行的新示例
+- 删除或降级旧 `Task / IR / Engine` 文档入口
+- `molexp.__init__` 去除 eager import
+
+退出条件：
+
+- README 中所有 import path 均真实存在
+- Quick Start 能在测试中跑通最小样例
+- `python -c "from molexp.server.app import create_app"` 在本地环境可成功导入
+
+## Phase 2：领域模型与持久化修复
+
+目标：
+让 Experiment/Run 的产品语义重新落到真实模型上，同时消除双重真相源。
+
+交付物：
+
+- 重构 `ExperimentMetadata` 与 `RunMetadata`
+- 移除父 metadata 中重复 child 列表
+- 统一创建 API 的参数模型
+- 统一 asset library 的查找和索引语义
+
+退出条件：
+
+- HTTP 请求模型与 Python API 使用同一组核心字段
+- 删除/列举/读取行为不再依赖重复状态
+- run/experiment 的响应字段均来自真实模型，而不是 `getattr(..., None)` 猜测
+
+## Phase 3：Server Contract 修复
+
+目标：
+把 server 从“原型路由集合”修到“可依赖 contract”。
+
+交付物：
+
+- 修复所有方法签名不匹配的路由
+- 移除 dead code、注释式补丁和不可达重试逻辑
+- 未完成端点统一返回 `501`
+- 生成稳定的 OpenAPI 文档
+
+退出条件：
+
+- 所有已暴露路由至少有一个成功路径测试
+- 所有未完成路由有明确失败测试
+- 资产上传、下载、run start、project/experiment CRUD 可端到端运行
+
+## Phase 4：Agent 与 Execution 能力显式化
+
+目标：
+把 agent/execution 从“部分可见、部分 stub”改为“已实现则可用，未实现则显式关闭”。
+
+交付物：
+
+- agent runtime availability 检测
+- session 持久化与事件流 contract 固化
+- execution/plan 能力按实现状态分层暴露
+- server 文档中标注 capability matrix
+
+退出条件：
+
+- 不再返回 stub session
+- session/events 行为在单进程与恢复场景下有明确测试
+- execution 入口不再误导用户以为已完整可用
+
+## Phase 5：回归清理与发布门禁
+
+目标：
+防止问题再次回流。
+
+交付物：
+
+- import smoke tests
+- doc smoke tests
+- API contract tests
+- “公共表面回归检查” CI 门禁
+
+退出条件：
+
+- 新 PR 无法再引入不存在的 import path 到 README/Quick Start
+- 新增路由必须附带 contract test
+- 顶层导入副作用被测试锁住
+
+---
+
+## 8. 验收标准
+
+达到以下标准，视为本 spec 完成：
+
+1. README、Quick Start、HTTP API、Python API 共享同一套术语和对象模型
+2. `Project / Experiment / Run` 的创建、读取、执行、状态更新路径不再依赖历史字段猜测
+3. server 不再存在签名错配、不可达修复逻辑和伪成功返回
+4. 顶层导入不要求远程执行环境、数据库路径或外部服务
+5. 未实现能力全部显式 gated
+6. 文档示例具备 smoke 测试
+
+---
+
+## 9. 风险与缓解
+
+### 风险 1：重构期间新旧代码并存导致继续扩散
+
+缓解：
+
+- 先执行 Phase 0 清单化
+- 所有公共入口先分类，再决定保留/删除
+
+### 风险 2：为快速修复 server 而继续堆积 `getattr` 和特判
+
+缓解：
+
+- 规定 response model 只能映射真实领域字段
+- 不允许通过“猜字段”维持表面兼容
+
+### 风险 3：删除旧文档后短期信息缺口
+
+缓解：
+
+- 在新 README 和 Quick Start 中补最小闭环
+- 历史设计提案保留，但明确标为历史/迁移文档
+
+### 风险 4：可选依赖拆分影响已有测试
+
+缓解：
+
+- 先建立 import smoke
+- 再做惰性加载改造
+
+---
+
+## 10. 决策摘要
+
+本 spec 的核心结论只有三条：
+
+1. Molexp 必须只有一套公共架构叙事
+2. 领域模型、接口契约、文档示例必须从同一个真相源生成
+3. 未完成能力和可选能力必须显式化，不能再通过 stub、历史残留和导入副作用泄漏到产品表面
+
+如果这三条不先完成，继续叠加 workflow、agent、server 功能只会放大维护成本和首日使用摩擦。
diff --git a/docs/developer/architecture-convergence-work-breakdown-zh.md b/docs/developer/architecture-convergence-work-breakdown-zh.md
new file mode 100644
index 00000000..3f1d7852
--- /dev/null
+++ b/docs/developer/architecture-convergence-work-breakdown-zh.md
@@ -0,0 +1,620 @@
+# Molexp 架构收敛实施拆分
+
+> 关联文档：[architecture-convergence-spec-zh.md](./architecture-convergence-spec-zh.md)
+> 用途：把收敛 spec 拆成可以直接排期和实施的工作包
+> 状态：Draft v1
+
+---
+
+## 1. 使用方式
+
+本文件不重复解释为什么要做，而是回答三个问题：
+
+1. 先做什么
+2. 每一步改哪些东西
+3. 做到什么程度算完成
+
+建议按 workstream + issue 的方式执行。
+
+- workstream 用来分责任边界
+- issue 用来落具体变更
+- milestone 用来控制顺序和依赖
+
+---
+
+## 2. 实施顺序
+
+建议按以下顺序推进：
+
+1. 冻结公共表面和导入边界
+2. 修复核心领域模型和持久化真相源
+3. 修复 server contract 与路由实现
+4. 清理未完成能力的暴露方式
+5. 重写文档与示例
+6. 加上 smoke/contract 门禁
+
+原因：
+
+- 不先冻结公共表面，后续每一步都会返工
+- 不先修领域模型，server 修复会继续堆 `getattr` 和特判
+- 不先修导入边界，测试和本地使用都会继续被可选依赖污染
+
+---
+
+## 3. Workstreams
+
+## WS1：公共 API 与包边界收敛
+
+目标：
+
+- 明确 Molexp 只支持一套公共模型
+- 清理顶层 import 副作用
+- 把历史残留 API 从文档和入口层拿掉
+
+涉及模块：
+
+- `src/molexp/__init__.py`
+- `src/molexp/workflow/__init__.py`
+- `src/molexp/workflow/remote.py`
+- `README.md`
+- `docs/get-started/*`
+- `docs/core/*`
+
+完成标准：
+
+- 顶层 import 不初始化远程执行基础设施
+- README 中所有 import path 真实存在
+- Quick Start 描述的新用户路径能运行
+
+## WS2：领域模型与持久化修复
+
+目标：
+
+- 让 `Experiment` 和 `Run` 承载真实产品语义
+- 消除 parent metadata 与目录结构的双重真相源
+- 统一 Python API 和 HTTP API 的字段模型
+
+涉及模块：
+
+- `src/molexp/workspace/metadata.py`
+- `src/molexp/workspace/workspace.py`
+- `src/molexp/workspace/project.py`
+- `src/molexp/workspace/experiment.py`
+- `src/molexp/workspace/run.py`
+- `src/molexp/workspace/asset.py`
+
+完成标准：
+
+- `ExperimentMetadata` 与 `RunMetadata` 字段能支撑当前对外文案
+- 删除/列举逻辑不再依赖重复索引
+- asset 语义统一，不再混用按 name 查找和按 asset_id 查找
+
+## WS3：Server Contract 修复
+
+目标：
+
+- 请求模型、响应模型、路由实现、领域模型完全对齐
+- 清除不可达代码、签名错配和伪修复逻辑
+
+涉及模块：
+
+- `src/molexp/server/schemas/requests.py`
+- `src/molexp/server/schemas/responses.py`
+- `src/molexp/server/routes/*.py`
+- `src/molexp/server/app.py`
+- `src/molexp/server/dependencies.py`
+
+完成标准：
+
+- 所有公开路由都能解释成真实模型操作
+- 所有 response 字段都来自真实字段，不靠 `getattr` 猜测
+- OpenAPI 能代表真实可用行为
+
+## WS4：未完成能力 gating
+
+目标：
+
+- agent、execution、registry、remote 这类未完成能力显式化
+- 未启用和未实现是明确错误，不是伪成功
+
+涉及模块：
+
+- `src/molexp/server/routes/agent.py`
+- `src/molexp/server/routes/execution.py`
+- `src/molexp/server/routes/registry.py`
+- `src/molexp/agent/*`
+- `src/molexp/workflow/runtime.py`
+
+完成标准：
+
+- 不再返回 stub session
+- 未实现端点统一返回明确错误
+- 文档不再宣称这些能力已可用
+
+## WS5：文档和示例重写
+
+目标：
+
+- README、Quick Start、Core 文档全部切到唯一公共模型
+- 删除失效 import path 和旧架构叙事
+
+涉及模块：
+
+- `README.md`
+- `docs/index.md`
+- `docs/get-started/*`
+- `docs/core/*`
+- `docs/workspace/*`
+
+完成标准：
+
+- 文档不再引用不存在模块
+- 文档中的创建/执行路径与当前代码一致
+- 旧 `Task / IR / Engine` 文档要么删除，要么明确标历史
+
+## WS6：测试与门禁
+
+目标：
+
+- 把公共表面收敛后的行为锁住
+- 防止 README、导入边界、server contract 再次漂移
+
+涉及模块：
+
+- `tests/server/*`
+- `tests/workspace/*`
+- `tests/workflow/*`
+- 新增 smoke/contract tests
+
+完成标准：
+
+- 顶层 import smoke 测试通过
+- Quick Start smoke 测试通过
+- server contract tests 覆盖所有公开路由
+
+---
+
+## 4. Issue 拆分
+
+下面的 issue 顺序已经按依赖排好，适合直接开工。
+
+## I0：公共表面清单化
+
+目标：
+
+- 产出一份当前公开 API、历史残留 API、待删除 API 的清单
+
+主要动作：
+
+- 梳理 README、docs、server routes、`__all__`
+- 标注每个入口是 `supported`、`internal`、`remove`
+- 标注每个未完成能力的现状和 gating 策略
+
+依赖：
+
+- 无
+
+产物：
+
+- 一份清单文档或 issue comment
+
+Definition of Done：
+
+- 后续所有实现都以这份清单为准
+
+## I1：顶层 import 去副作用
+
+目标：
+
+- `import molexp` 与 `from molexp.server.app import create_app` 不触发 `molq` 初始化
+
+主要动作：
+
+- 改造 `src/molexp/__init__.py`，避免 eager import 子模块
+- 审查 `src/molexp/workflow/__init__.py` 的 import 树
+- 将 `remote` 相关能力改为按需加载
+
+涉及文件：
+
+- `src/molexp/__init__.py`
+- `src/molexp/workflow/__init__.py`
+- `src/molexp/workflow/remote.py`
+
+依赖：
+
+- I0
+
+Definition of Done：
+
+- server tests 至少可以完成 import 和 app 初始化
+- 不再出现因远程执行依赖导致的导入失败
+
+## I2：README 与 Quick Start 收敛到新模型
+
+目标：
+
+- 用户第一眼看到的内容就是唯一支持模型
+
+主要动作：
+
+- README 全部切换到 `molexp.workflow` / `molexp.workspace` 当前实际 API
+- 删除或替换旧 `TaskEngine`、`workflow.node`、`workspace.core` 等路径
+- Quick Start 改写为可运行的最小例子
+
+涉及文件：
+
+- `README.md`
+- `docs/index.md`
+- `docs/get-started/overview.md`
+- `docs/get-started/quick-start.md`
+
+依赖：
+
+- I1
+
+Definition of Done：
+
+- 文档中的 import path 全部真实存在
+- 样例代码可以被 smoke 测试执行
+
+## I3：Experiment 模型恢复产品语义
+
+目标：
+
+- `Experiment` 真正表示“可重复执行的 workflow 定义”
+
+主要动作：
+
+- 为 `ExperimentMetadata` 增加 workflow 相关字段
+- 调整 `Project.create_experiment()` 参数签名
+- 统一 CLI、server request、response 的 experiment 字段
+
+涉及文件：
+
+- `src/molexp/workspace/metadata.py`
+- `src/molexp/workspace/project.py`
+- `src/molexp/workspace/experiment.py`
+- `src/molexp/server/schemas/requests.py`
+- `src/molexp/server/schemas/responses.py`
+- `src/molexp/cli/__init__.py`
+
+依赖：
+
+- I0
+
+Definition of Done：
+
+- experiment create/read 的 workflow 字段来自真实 metadata
+- 不再通过 `workflow_template` 一类悬空属性拼响应
+
+## I4：Run 模型恢复执行快照语义
+
+目标：
+
+- `Run` 真正表示一次具体执行及其快照
+
+主要动作：
+
+- 明确 `RunMetadata` 中的 snapshot 和 execution 相关字段
+- 统一 `create_run()`、状态更新、执行上下文落盘逻辑
+- 修复 `RunResponse` 对 `workflow_snapshot`、`finished_at` 的映射
+
+涉及文件：
+
+- `src/molexp/workspace/metadata.py`
+- `src/molexp/workspace/run.py`
+- `src/molexp/server/schemas/responses.py`
+- `src/molexp/server/routes/run.py`
+
+依赖：
+
+- I3
+
+Definition of Done：
+
+- run read/status/update 使用一致字段
+- run 响应不再依赖不存在的属性
+
+## I5：移除双重真相源
+
+目标：
+
+- parent metadata 不再维护重复 child 列表
+
+主要动作：
+
+- 去掉 `WorkspaceMetadata.projects`
+- 去掉 `ProjectMetadata.experiments`
+- 评估 `ProjectMetadata.assets` 是否保留为可重建缓存，否则删除
+- 调整 create/delete/list 流程
+
+涉及文件：
+
+- `src/molexp/workspace/metadata.py`
+- `src/molexp/workspace/workspace.py`
+- `src/molexp/workspace/project.py`
+- `src/molexp/workspace/base.py`
+
+依赖：
+
+- I3
+
+Definition of Done：
+
+- create/list/delete 只依赖目录结构和子 metadata
+- 删除后不会留下静默脏索引
+
+## I6：统一 AssetLibrary contract
+
+目标：
+
+- 资产操作语义统一，不再混用 name 和 asset_id
+
+主要动作：
+
+- 确定 `get_asset(name)` 与 `get_by_id(asset_id)` 的正式接口
+- 若 server 需要按 ID 读取，就显式补 API，而不是假定存在 `get()`
+- 明确下载 payload 的正式接口
+
+涉及文件：
+
+- `src/molexp/workspace/asset.py`
+- `src/molexp/server/routes/asset.py`
+- `src/molexp/server/routes/project.py`
+
+依赖：
+
+- I5
+
+Definition of Done：
+
+- asset 上传、查询、下载的路由都调用真实存在的方法
+- 不再有按 name/index 与按 id/path 混乱切换
+
+## I7：修复 server 路由签名错配
+
+目标：
+
+- 去掉当前路由层里的假设式调用和不可达修复代码
+
+主要动作：
+
+- 修 `project` asset upload 路由
+- 修 `run.start` 路由对 `Run` 上下文 API 的调用
+- 对所有 CRUD 路由做一次签名一致性检查
+
+涉及文件：
+
+- `src/molexp/server/routes/project.py`
+- `src/molexp/server/routes/run.py`
+- `src/molexp/server/routes/experiment.py`
+- `src/molexp/server/routes/asset.py`
+
+依赖：
+
+- I4
+- I6
+
+Definition of Done：
+
+- 路由代码中不再出现不可达补丁逻辑
+- 所有调用都能直接映射到真实对象方法
+
+## I8：请求/响应模型重对齐
+
+目标：
+
+- 请求模型不要求实现不存在的数据
+- 响应模型不暴露实现不存在的数据
+
+主要动作：
+
+- 重写 `requests.py`
+- 重写 `responses.py`
+- 为每个 endpoint 明确字段来源
+
+涉及文件：
+
+- `src/molexp/server/schemas/requests.py`
+- `src/molexp/server/schemas/responses.py`
+- 对应 routes
+
+依赖：
+
+- I3
+- I4
+- I6
+
+Definition of Done：
+
+- API schema 与真实代码一致
+- OpenAPI 不再包含误导性必填字段
+
+## I9：未完成能力统一 gating
+
+目标：
+
+- agent、execution、registry 的未完成状态可解释、可预测
+
+主要动作：
+
+- agent route 不再返回 stub session
+- execution/plan/registry 明确返回 `501` 或能力未启用错误
+- 文档同步降级这些能力表述
+
+涉及文件：
+
+- `src/molexp/server/routes/agent.py`
+- `src/molexp/server/routes/execution.py`
+- `src/molexp/server/routes/registry.py`
+- `src/molexp/agent/*`
+
+依赖：
+
+- I0
+
+Definition of Done：
+
+- 用户不会收到“看起来成功但实际没做事”的响应
+
+## I10：文档全量重写与历史文档降级
+
+目标：
+
+- 文档完全以当前唯一公共模型为准
+
+主要动作：
+
+- 重写 `docs/core/*` 和 `docs/workspace/*`
+- 对旧架构文档加“历史/迁移文档”标记，或直接移除导航入口
+- 清理 README 中失效链接
+
+涉及文件：
+
+- `README.md`
+- `docs/index.md`
+- `docs/core/*`
+- `docs/workspace/*`
+
+依赖：
+
+- I2
+- I8
+- I9
+
+Definition of Done：
+
+- 搜索文档中不再出现已删除的公共 import path
+
+## I11：smoke 与 contract tests
+
+目标：
+
+- 把本次收敛后的产品表面锁住
+
+主要动作：
+
+- 增加 import smoke tests
+- 增加 Quick Start smoke tests
+- server route contract tests 覆盖 CRUD、asset、status、gating 行为
+
+建议测试集：
+
+- `tests/smoke/test_imports.py`
+- `tests/smoke/test_quickstart_examples.py`
+- `tests/server/test_contract_projects.py`
+- `tests/server/test_contract_experiments.py`
+- `tests/server/test_contract_runs.py`
+- `tests/server/test_contract_assets.py`
+- `tests/server/test_contract_capability_gating.py`
+
+依赖：
+
+- I1
+- I7
+- I8
+- I9
+
+Definition of Done：
+
+- 文档、导入、路由 contract 漂移会被 CI 阻止
+
+---
+
+## 5. 建议里程碑
+
+## M1：公共表面冻结
+
+包含：
+
+- I0
+- I1
+- I2
+
+可见成果：
+
+- 新用户至少能 import 和看懂正确入口
+
+## M2：领域模型收口
+
+包含：
+
+- I3
+- I4
+- I5
+- I6
+
+可见成果：
+
+- `Project / Experiment / Run / Asset` 语义与真实数据结构一致
+
+## M3：Server 可依赖
+
+包含：
+
+- I7
+- I8
+- I9
+
+可见成果：
+
+- API 可用性不再靠运气
+
+## M4：文档与门禁闭环
+
+包含：
+
+- I10
+- I11
+
+可见成果：
+
+- 文档、测试、实现同构
+
+---
+
+## 6. 推荐开工方式
+
+如果要立即实施，我建议按下面节奏：
+
+第 1 轮：
+
+- I1 顶层 import 去副作用
+- I2 README / Quick Start 收敛
+
+第 2 轮：
+
+- I3 Experiment 模型
+- I4 Run 模型
+- I5 双重真相源移除
+
+第 3 轮：
+
+- I6 AssetLibrary contract
+- I7 路由签名修复
+- I8 请求/响应模型重对齐
+
+第 4 轮：
+
+- I9 能力 gating
+- I10 文档全量重写
+- I11 smoke/contract tests
+
+这样做的好处是：
+
+- 每轮都能形成稳定增量
+- 不会先修文档再推翻
+- 能较早恢复最关键的开发和测试路径
+
+---
+
+## 7. 实施准备清单
+
+在真正开始改代码前，建议先确认：
+
+- 是否接受“旧 API 不再对外承诺”
+- 是否接受 `Experiment` / `Run` 恢复 workflow snapshot 语义
+- 是否接受未完成能力统一返回错误而不是 stub
+- 是否接受本轮优先修 contract，不扩新功能
+
+如果以上四点都接受，就可以按本拆分直接开工。
diff --git a/docs/developer/pydanticai-graph-integration-proposal-zh.md b/docs/developer/pydanticai-graph-integration-proposal-zh.md
new file mode 100644
index 00000000..5ea91159
--- /dev/null
+++ b/docs/developer/pydanticai-graph-integration-proposal-zh.md
@@ -0,0 +1,1016 @@
+# Molexp 接入 `PydanticAI` 并以 `pydantic-graph` 重构 Workflow 的设计提案
+
+> 状态：设计提案 v3
+> 目标：将 `molexp` 演进为"完整工作流与资产管理平台 + 自主驱动系统"。
+> 关键决策：
+> - `workspace` 必须保留，并继续作为系统真相源
+> - 全量引入 `PydanticAI` 承载 `molexp.agent`
+> - 以封装方式引入 `pydantic-graph` 替换 workflow kernel
+> - **彻底重构，不向后兼容**，项目仍处于高速开发期，不保留任何兼容 shim
+> - 用户不直接操作第三方库，所有能力通过 `molexp` 自身 facade 暴露
+
+---
+
+## 1. 提案摘要
+
+本提案建议把 `molexp` 重构为三层架构：
+
+```
+Molexp Product Layer
+  = Workspace + Assets + Project/Experiment/Run + UI/API
+
+Molexp Agent Layer
+  = Goal / Session / Planner / Tooling / Approval / Replan
+  = built on top of PydanticAI
+
+Molexp Workflow Layer
+  = WorkflowSpec / WorkflowRuntime / GraphExecution
+  = built on top of pydantic-graph
+```
+
+核心思想：
+
+- `PydanticAI` 负责智能控制层（agent、tool、session、replanning）
+- `pydantic-graph` 负责 workflow runtime（DAG 编排、步骤执行、持久化）
+- `molexp` 继续负责产品语义、workspace、asset、experiment/run、用户 API、可观测性和持久化
+
+最终用户使用体验：
+
+- **显式 workflow 模式**：用户声明步骤和依赖，系统编译执行（支持函数式和 OOP 两种写法）
+- **agent 模式**：用户给一个目标，系统自动规划、调用工具、产生观测、重规划
+- 两种模式共享 workspace / run / assets
+
+所有底层实现细节（`pydantic_ai.Agent`、`pydantic_graph.Graph`、`BaseNode`）完全封装在 `molexp` 内部，不暴露给用户。
+
+---
+
+## 2. pydantic-graph 技术调研结论
+
+### 2.1 Stable API（原始 API）
+
+**节点定义**：节点是实现 `BaseNode[StateT, DepsT, RunEndT]` 的 dataclass，`run()` 方法始终是 async，返回类型注解决定出边：
+
+```python
+@dataclass
+class MyNode(BaseNode[StateT, DepsT, RunEndT]):
+    input_value: int
+
+    async def run(self, ctx: GraphRunContext[StateT]) -> NextNode | End[int]:
+        ctx.state.counter += 1
+        if done:
+            return End(self.input_value)
+        return NextNode(self.input_value + 1)
+```
+
+**共享状态**：`GraphRunContext.state` 是一个 dataclass，所有节点共享并可就地修改。数据流通过节点 dataclass 字段（构造时传入）或共享 state 传递。
+
+**循环（Actor 模式基础）**：节点可以在返回类型中包含自身，形成循环：
+
+```python
+@dataclass
+class ActorNode(BaseNode[StateT]):
+    async def run(self, ctx: GraphRunContext[StateT]) -> ActorNode | End[None]:
+        msg = ctx.state.inbox.get_nowait()
+        result = process(msg)
+        ctx.state.outbox.put_nowait(result)
+        return ActorNode()  # 回到自身，持续运行
+```
+
+**持久化（内建）**：Stable API 有完整的 `BaseStatePersistence` 接口：
+
+| 内建实现 | 存储 | 说明 |
+|----------|------|------|
+| `SimpleStatePersistence` | 内存，仅最新 | 默认 |
+| `FullStatePersistence` | 内存列表 | 支持 `dump_json()` / `load_json()` |
+| `FileStatePersistence` | JSON 文件 | 文件锁，适合单 run 恢复 |
+
+快照结构（`NodeSnapshot`）包含：执行前完整 state、节点实例、时间戳、状态（created/pending/running/success/error）。可通过 `graph.initialize()` + `graph.iter_from_persistence()` 实现跨进程恢复。
+
+**关键限制**：**Stable API 不支持并行节点执行**（GitHub issue #704 open）。所有节点严格串行推进。
+
+### 2.2 Beta API
+
+Beta API 引入构建器模式和真正的并行能力。数据流模型（`StepContext.inputs` 携带类型化输入）与当前 `Link.mapping` 的语义更接近：
+
+```python
+g = GraphBuilder(state_type=MyState, input_type=list[int], output_type=list[int])
+
+@g.step
+async def process_item(ctx: StepContext[MyState, None, int]) -> int:
+    return ctx.inputs * 2  # 类型化的上游输入
+
+collect = g.join(reduce_list_append, initial_factory=list[int])
+
+g.add(
+    g.edge_from(g.start_node).map().to(process_item),  # 并行扇出
+    g.edge_from(process_item).to(collect),
+    g.edge_from(collect).to(g.end_node),
+)
+```
+
+**Beta API 关键限制**：**没有内建持久化**。官方明确说明原因是并行执行时一致性快照的复杂性。官方建议配合 Temporal / DBOS / Prefect 做持久化。
+
+### 2.3 多 Actor 并发的技术结论
+
+pydantic-graph 的并发支持现状：
+
+| 场景 | Stable API | Beta API |
+|------|-----------|----------|
+| 单 Actor 循环 | 支持（节点返回自身） | 支持（`@g.stream` 或循环） |
+| 并行扇出（一对多） | 不支持 | 支持（`.map()` + `.join()`） |
+| 多 Actor pipeline（A→B→C） | 不支持并发 | 不支持（无内建 pipeline 模式） |
+| 多 Actor 双向通信 | 不支持 | 不支持 |
+
+**缓解策略**：多 Actor pipeline 场景，adapter 层在 pydantic-graph 之外用 asyncio 并发运行多个 graph 实例，通过 `asyncio.Queue` 传递消息。这把多 Actor 协调责任完全封装在 `molexp.workflow.runtime` 内部，用户侧 API 不感知。
+
+---
+
+## 3. 设计目标
+
+### 3.1 产品目标
+
+- 保留并强化 `workspace / assets / project / experiment / run`
+- 让 workflow kernel 不再自研维护
+- 让 agent/autonomy 能力成为一等公民
+- 用户只面向 `molexp` API，不接触底层第三方库
+
+### 3.2 工程目标
+
+- **彻底重构，不向后兼容**：删除现有 `WorkflowCompiler`、`WorkflowEngine`、`Link`，不保留任何 shim。项目处于高速开发期，技术债务清零优先于迁移平滑。
+- 降低自研 workflow runtime 维护成本
+- API 风格向 pydantic-graph / PydanticAI 借鉴，同时保留 OOP 类写法（两种风格均一等支持）
+- 不让第三方库类型污染 `molexp` 公共 API
+
+### 3.3 非目标
+
+- 不把 `molexp` 变成 `PydanticAI` 的薄皮壳
+- 不让用户直接写 `Agent(...)` 或 `Graph(...)`
+- 不为旧用户提供迁移脚本或自动升级工具
+
+---
+
+## 4. API 设计哲学
+
+### 4.1 双风格统一支持
+
+molexp 的新 API 借鉴 pydantic-graph 的函数式装饰器风格，同时保留完整的 OOP 类写法。两种风格在运行时等价，用户根据场景和偏好选择，底层统一编译到相同的 pydantic-graph 节点。
+
+#### Workflow Step — 两种写法
+
+**函数式（借鉴 `@g.step`）**：
+
+```python
+from molexp.workflow import workflow, StepContext
+
+wf = workflow(name="data-pipeline")
+
+@wf.step(depends_on=["fetch"])
+async def validate(ctx: StepContext[DataState, DataDeps, FetchResult]) -> ValidateResult:
+    data = ctx.inputs          # 类型化的上游输入（FetchResult）
+    ctx.state.validated += 1   # 共享状态
+    return ValidateResult(data=cleaned(data))
+```
+
+**OOP（保留类继承）**：
+
+```python
+from molexp.workflow import Step, StepContext
+
+class ValidateStep(Step[DataState, DataDeps, FetchResult, ValidateResult]):
+    config: ValidateConfig     # Pydantic 模型，config-as-state 模式
+
+    async def execute(self, ctx: StepContext[DataState, DataDeps, FetchResult]) -> ValidateResult:
+        data = ctx.inputs
+        ctx.state.validated += 1
+        return ValidateResult(data=cleaned(data, threshold=self.config.threshold))
+```
+
+#### Actor — 两种写法
+
+Actor 在底层编译为 pydantic-graph 的循环节点（节点返回自身）。多 Actor pipeline 由 `MultiActorRunner` 以 asyncio 并发调度。
+
+**函数式**：
+
+```python
+@wf.actor(depends_on=["ingest"])
+async def filter_stream(
+    ctx: ActorContext[StreamState, StreamDeps, RawEvent]
+) -> AsyncIterator[FilteredEvent]:
+    while True:
+        msg = await ctx.receive()
+        if msg.quality > ctx.state.threshold:
+            yield FilteredEvent(msg)
+```
+
+**OOP**：
+
+```python
+from molexp.workflow import Actor, ActorContext
+
+class FilterActor(Actor[StreamState, StreamDeps, RawEvent, FilteredEvent]):
+    config: FilterConfig
+
+    async def run(
+        self, ctx: ActorContext[StreamState, StreamDeps, RawEvent]
+    ) -> AsyncIterator[FilteredEvent]:
+        while True:
+            msg = await ctx.receive()
+            if msg.quality > self.config.threshold:
+                yield FilteredEvent(msg)
+```
+
+#### Agent Tool — 两种写法
+
+**函数式（借鉴 `@agent.tool`）**：
+
+```python
+from molexp.agent import agent_tool, ToolContext
+
+@agent_tool(level="workspace", requires_approval=False)
+async def read_asset(ctx: ToolContext, asset_name: str) -> AssetContent:
+    return ctx.workspace.assets.read(asset_name)
+```
+
+**OOP**：
+
+```python
+from molexp.agent import Tool, ToolContext
+
+class ReadAssetTool(Tool):
+    name = "workspace.read_asset"
+    level = "workspace"
+    requires_approval = False
+
+    async def call(self, ctx: ToolContext, asset_name: str) -> AssetContent:
+        return ctx.workspace.assets.read(asset_name)
+```
+
+### 4.2 核心上下文类型
+
+借鉴 pydantic-graph 的 `StepContext[StateT, DepsT, InputT]` 设计，molexp 暴露三个统一的上下文类型：
+
+```python
+# Workflow Step 上下文（对应 pydantic-graph StepContext）
+class StepContext(Generic[StateT, DepsT, InputT]):
+    state: StateT       # 共享可变状态
+    deps: DepsT         # 注入的依赖（workspace、run、外部服务）
+    inputs: InputT      # 类型化的上游输入
+
+# Actor 上下文（扩展 StepContext，增加消息收发）
+class ActorContext(StepContext[StateT, DepsT, InputT]):
+    async def receive(self) -> InputT: ...
+    async def send(self, output: OutputT) -> None: ...
+
+# Agent Tool 上下文
+class ToolContext:
+    workspace: Workspace
+    run: Run | None
+    session: AgentSession
+```
+
+### 4.3 与 pydantic-graph 的风格对照
+
+| 概念 | pydantic-graph 原始 | molexp 对应 |
+|------|---------------------|-------------|
+| 节点定义 | `@dataclass class Foo(BaseNode)` | `@wf.step` / `class FooStep(Step)` |
+| 上下文 | `GraphRunContext[StateT]` | `StepContext[StateT, DepsT, InputT]` |
+| 输入数据 | 节点 dataclass 字段 | `ctx.inputs`（类型化） |
+| 共享状态 | `ctx.state` | `ctx.state`（同） |
+| 终止 | `End(data)` | `WorkflowResult`（内部封装） |
+| 持久化 | `BaseStatePersistence` | `RunStorePersistence`（实现该接口） |
+| 并行扇出 | `.map()` + `.join()` | `parallel_map()` + `join()` |
+
+---
+
+## 5. 用户侧用例
+
+### 5.1 Workspace 层用例
+
+**用例 1：初始化工作区并组织项目**
+
+```python
+from molexp.workspace import Workspace
+
+ws = Workspace.from_env()
+
+project = ws.create_project(
+    name="Polymer Stability Study",
+    description="GNN-based stability prediction for polymer chains",
+)
+
+experiment = project.create_experiment(
+    name="Baseline GNN",
+    workflow_source="workflows/train_gnn.py",
+    tags=["baseline", "gnn"],
+)
+```
+
+**用例 2：创建 Run 并记录资产与指标**
+
+```python
+run = experiment.create_run(
+    parameters={"lr": 1e-3, "hidden_dim": 128, "epochs": 100},
+)
+
+with run.start() as ctx:
+    ctx.log("Training started")
+    ctx.assets.register("training_data", path="/data/polymer_train.h5")
+
+    model, metrics = train(ctx.parameters)
+
+    ctx.log_metrics({"val_loss": metrics.val_loss, "mae": metrics.mae})
+    ctx.assets.create("checkpoint", model.save("/tmp/model.pt"))
+    ctx.assets.create("predictions", "/tmp/predictions.csv")
+```
+
+**用例 3：比较多个 Run**
+
+```python
+runs = experiment.list_runs()
+comparison = experiment.compare_runs(
+    run_ids=[r.run_id for r in runs],
+    metrics=["val_loss", "mae"],
+    parameters=["lr", "hidden_dim"],
+)
+comparison.to_dataframe().sort_values("val_loss")
+```
+
+**用例 4：层级资产库**
+
+```python
+ws.assets.create("bert_pretrained", "/models/bert-base.pt")        # 全局
+project.assets.create("polymer_dataset", "/data/qm9.tar.bz2")     # 项目内
+experiment.assets.create("mol_features", "/data/features.h5")     # 实验内
+run.assets.create("run_output", "/outputs/results.json")           # 单次执行
+
+# 向上查找：run → experiment → project → workspace
+asset = run.assets.resolve("bert_pretrained")
+```
+
+---
+
+### 5.2 Workflow 层用例
+
+**用例 1：函数式风格定义线性 workflow**
+
+```python
+from molexp.workflow import workflow, StepContext
+from molexp.workspace import DataState, DataDeps
+
+wf = workflow(name="data-pipeline")
+
+@wf.step
+async def fetch(ctx: StepContext[DataState, DataDeps, None]) -> FetchResult:
+    return FetchResult(data=ctx.deps.storage.read(ctx.state.source))
+
+@wf.step(depends_on=["fetch"])
+async def validate(ctx: StepContext[DataState, DataDeps, FetchResult]) -> ValidateResult:
+    ctx.state.row_count = len(ctx.inputs.data)
+    return ValidateResult(data=clean(ctx.inputs.data))
+
+@wf.step(depends_on=["validate"])
+async def publish(ctx: StepContext[DataState, DataDeps, ValidateResult]) -> PublishResult:
+    path = ctx.deps.storage.write(ctx.inputs.data)
+    ctx.run.assets.create("cleaned_dataset", path)
+    return PublishResult(asset_id="cleaned_dataset")
+
+run = experiment.create_run(parameters={"source": "s3://bucket/raw"})
+result = await wf.execute(run=run)
+print(result.outputs["publish"].asset_id)
+```
+
+**用例 2：OOP 风格定义 workflow（可复用、可配置）**
+
+```python
+from molexp.workflow import Step, StepContext, WorkflowBuilder
+
+class FetchStep(Step[DataState, DataDeps, None, FetchResult]):
+    config: FetchConfig
+
+    async def execute(self, ctx: StepContext[DataState, DataDeps, None]) -> FetchResult:
+        return FetchResult(data=ctx.deps.storage.read(self.config.source))
+
+class ValidateStep(Step[DataState, DataDeps, FetchResult, ValidateResult]):
+    config: ValidateConfig
+
+    async def execute(self, ctx: StepContext[DataState, DataDeps, FetchResult]) -> ValidateResult:
+        ctx.state.row_count = len(ctx.inputs.data)
+        return ValidateResult(data=clean(ctx.inputs.data, schema=self.config.schema))
+
+# 组装 workflow（与函数式等价，底层同一套编译路径）
+wf = (
+    WorkflowBuilder(name="data-pipeline")
+    .add(FetchStep(config=FetchConfig(source="s3://bucket/raw")))
+    .add(ValidateStep(config=ValidateConfig(schema="polymer_v2")), depends_on=["fetch"])
+    .build()
+)
+
+result = await wf.execute(run=run)
+```
+
+**用例 3：并行扇出（Map / Reduce）**
+
+```python
+from molexp.workflow import workflow, StepContext, parallel_map, join
+
+wf = workflow(name="grid-search")
+
+@wf.step
+async def prepare(ctx: StepContext[SearchState, None, None]) -> PrepareResult:
+    return PrepareResult(grid=ctx.state.parameter_grid)
+
+@parallel_map(wf, fan_out_over="grid", depends_on=["prepare"])
+async def train_variant(ctx: StepContext[SearchState, None, GridPoint]) -> TrainResult:
+    # 每个 GridPoint 并发执行，底层用 pydantic-graph beta API .map()
+    model = train(lr=ctx.inputs.lr, hidden=ctx.inputs.hidden)
+    return TrainResult(val_loss=model.val_loss, config=ctx.inputs)
+
+@join(wf, reducer="best_by_val_loss", depends_on=["train_variant"])
+async def select_best(ctx: StepContext[SearchState, None, list[TrainResult]]) -> BestResult:
+    return min(ctx.inputs, key=lambda r: r.val_loss)
+
+run = experiment.create_run(parameters={
+    "parameter_grid": [
+        {"lr": 1e-3, "hidden": 64},
+        {"lr": 1e-4, "hidden": 128},
+        {"lr": 5e-4, "hidden": 256},
+    ]
+})
+result = await wf.execute(run=run)
+print(result.outputs["select_best"].config)
+```
+
+**用例 4：Workflow 暂停与恢复**
+
+```python
+# 启动，中途进程崩溃
+execution = await wf.start(run=run)
+print(execution.execution_id)   # "exec-abc123"
+
+# 重启后恢复（从 Run store 加载最后快照）
+execution = await wf.resume(run=run, execution_id="exec-abc123")
+result = await execution.wait()
+print(result.status)  # "completed"
+```
+
+**用例 5：流式 Actor Workflow**
+
+```python
+from molexp.workflow import workflow, Actor, ActorContext
+
+wf = workflow(name="streaming-pipeline", mode="streaming")
+
+class KafkaIngest(Actor[StreamState, StreamDeps, None, RawEvent]):
+    config: KafkaConfig
+
+    async def run(self, ctx: ActorContext[StreamState, StreamDeps, None]) -> AsyncIterator[RawEvent]:
+        async for msg in ctx.deps.kafka.consume(self.config.topic):
+            yield RawEvent(msg)
+
+@wf.actor(depends_on=["ingest"])
+async def quality_filter(ctx: ActorContext[StreamState, StreamDeps, RawEvent]) -> AsyncIterator[CleanEvent]:
+    while True:
+        msg = await ctx.receive()
+        if msg.quality > ctx.state.threshold:
+            yield CleanEvent(msg)
+
+wf.add(KafkaIngest(config=KafkaConfig(topic="mol-events")), name="ingest")
+
+run = experiment.create_run(parameters={"threshold": 0.8})
+async with wf.stream(run=run) as stream:
+    async for event in stream:
+        print(event)
+```
+
+**用例 6：步进执行（调试）**
+
+```python
+async with wf.iter(run=run) as graph_run:
+    async for step_event in graph_run:
+        print(f"[{step_event.step_name}] {step_event.status}")
+        if step_event.step_name == "validate" and step_event.status == "failed":
+            print("State at failure:", step_event.state)
+            break
+```
+
+---
+
+### 5.3 Agent 层用例
+
+**用例 1：目标驱动的自主实验**
+
+```python
+from molexp.agent import Goal, AgentService
+
+goal = Goal(
+    description="Prepare a validated polymer dataset and run a GNN baseline",
+    constraints={"project": "polymer-study", "max_runs": 3},
+    success_criteria=[
+        "dataset validated and published as experiment asset",
+        "at least one training run completed with val_loss < 0.05",
+    ],
+)
+
+service = AgentService.from_workspace("./lab")
+session = await service.run(goal)
+
+print(session.status)           # "completed"
+print(session.produced_runs)    # [Run(...), Run(...)]
+print(session.artifacts)        # [Asset("dataset"), Asset("checkpoint")]
+```
+
+**用例 2：监控 Session 时间线**
+
+```python
+session = await service.start(goal)
+
+async for event in session.stream_events():
+    match event:
+        case PlanCreatedEvent():
+            print("Plan:", event.plan_steps)
+        case ToolCallEvent():
+            print(f"→ {event.tool_name}({event.args})")
+        case WorkflowStartedEvent():
+            print(f"  workflow run: {event.run_id}")
+        case ObservationEvent():
+            print(f"  observation: {event.content}")
+        case ReplanEvent():
+            print(f"  replanning: {event.reason}")
+        case SessionCompletedEvent():
+            print(f"Done: {event.summary}")
+            break
+```
+
+**用例 3：函数式注册自定义 Tool**
+
+```python
+from molexp.agent import agent_tool, ToolContext
+
+# 用户可以用装饰器给 agent 注册自定义 tool
+@agent_tool(level="product", requires_approval=True)
+async def run_bayesian_step(
+    ctx: ToolContext, experiment_id: str, iteration: int
+) -> BayesianStepResult:
+    experiment = ctx.workspace.get_experiment(experiment_id)
+    run = experiment.create_run(parameters=suggest_next(iteration))
+    result = await training_workflow.execute(run=run)
+    return BayesianStepResult(val_loss=result.outputs["train"].val_loss, run_id=run.run_id)
+
+service = AgentService.from_workspace("./lab", extra_tools=[run_bayesian_step])
+session = await service.run(goal)
+```
+
+**用例 4：OOP 风格注册 Tool**
+
+```python
+from molexp.agent import Tool, ToolContext
+
+class RunBayesianStep(Tool):
+    name = "product.run_bayesian_step"
+    level = "product"
+    requires_approval = True
+
+    async def call(
+        self, ctx: ToolContext, experiment_id: str, iteration: int
+    ) -> BayesianStepResult:
+        experiment = ctx.workspace.get_experiment(experiment_id)
+        run = experiment.create_run(parameters=suggest_next(iteration))
+        result = await training_workflow.execute(run=run)
+        return BayesianStepResult(val_loss=result.outputs["train"].val_loss, run_id=run.run_id)
+
+service = AgentService.from_workspace("./lab", extra_tools=[RunBayesianStep()])
+```
+
+**用例 5：Human-in-the-loop 审批**
+
+```python
+from molexp.agent import ApprovalPolicy
+
+policy = ApprovalPolicy(
+    require_approval_for=["product.*", "workflow.execute"],
+    auto_approve=["workspace.read_*", "workflow.inspect"],
+)
+
+service = AgentService.from_workspace("./lab", approval_policy=policy)
+session = await service.start(goal)
+
+async for event in session.stream_events():
+    if isinstance(event, ApprovalRequestEvent):
+        print(f"Approval needed: {event.tool_name}({event.args})")
+        decision = input("Approve? [y/n]: ")
+        await session.respond_approval(event.request_id, approved=(decision == "y"))
+```
+
+**用例 6：Session 恢复与重放**
+
+```python
+# 进程重启后恢复
+session = await service.resume(session_id="sess-xyz789")
+async for event in session.stream_events(): ...
+
+# 事后重放时间线
+history = await service.get_session_history("sess-xyz789")
+for entry in history.timeline:
+    print(f"[{entry.ts}] {entry.event_type}: {entry.summary}")
+```
+
+---
+
+## 6. 内部架构
+
+### 6.1 分层结构
+
+```mermaid
+graph TD
+    A[User / UI / API] --> B[Molexp Facade Layer]
+    B --> C[Molexp Agent Service]
+    B --> D[Molexp Workflow Service]
+    B --> E[Molexp Workspace Service]
+
+    C --> F[PydanticAI Adapter]
+    F --> G[Tool Catalog]
+    F --> H[Session Store]
+
+    D --> I[WorkflowGraphCompiler]
+    I --> J[Graph Runtime Adapter]
+    J --> K1[pydantic-graph Stable API<br/>BATCH + 持久化]
+    J --> K2[pydantic-graph Beta API<br/>并行扇出]
+    J --> K3[MultiActorRunner<br/>asyncio + Queue]
+
+    G --> E
+    G --> D
+    E --> L[Workspace / Assets / Project / Experiment / Run]
+    D --> L
+    H --> L
+```
+
+### 6.2 Workflow 编译路径
+
+```
+WorkflowSpec（用户定义，函数式 or OOP）
+  ↓ WorkflowGraphCompiler
+  ├─ 纯 BATCH DAG         → pydantic-graph Stable API + RunStorePersistence
+  ├─ 含并行扇出           → pydantic-graph Beta API + 手动快照
+  └─ 含 Actor（streaming）→ MultiActorRunner（asyncio 并发）
+  ↓
+WorkflowExecution / WorkflowResult
+  → 写入 Run store（真相源）
+```
+
+### 6.3 持久化适配
+
+对 Stable API，实现 `RunStorePersistence(BaseStatePersistence)` 将每个 `NodeSnapshot` 原子写入 `Run` store：
+
+```python
+class RunStorePersistence(BaseStatePersistence[StateT, RunEndT]):
+    def __init__(self, run: Run): ...
+
+    async def snapshot_node(self, snapshot: NodeSnapshot) -> None:
+        # 原子写入 run.store/execution/{snapshot.id}.json
+        ...
+
+    async def load_next(self) -> NodeSnapshot | None:
+        # 读取 status='created' 的最早快照
+        ...
+```
+
+对 Beta API（无内建持久化），adapter 监听 step 完成事件，主动快照 state 到 Run store，格式与 Stable API 一致。
+
+### 6.4 多 Actor Pipeline 封装
+
+```python
+class MultiActorRunner:
+    """在 pydantic-graph 之外协调多个并发 Actor graph 实例。"""
+
+    def __init__(self, actor_specs: list[ActorStepSpec], run: Run):
+        self._graphs: dict[str, Graph] = {}
+        self._channels: dict[tuple[str, str], asyncio.Queue] = {}
+
+    async def start(self) -> None:
+        # 1. 为每条 actor link 分配 asyncio.Queue，注入各 GraphState
+        # 2. asyncio.gather 并发启动所有 graph 实例
+        # 3. 异常传播：任一 actor 失败 → 取消其余，写 run.status=failed
+        ...
+```
+
+`WorkflowSpec(mode="streaming")` 经 compiler 自动路由到 `MultiActorRunner`，用户不感知。
+
+### 6.5 Agent Tool 分层
+
+```
+Level 1: Workspace tools（只读，无需审批）
+  workspace.list_projects / list_experiments / list_assets / read_asset / get_run_metrics
+
+Level 2: Workflow tools（执行类，高风险需审批）
+  workflow.execute / resume / inspect / fetch_outputs / cancel
+
+Level 3: Product tools（写操作，部分需审批）
+  experiment.create_run / run.read_logs / run.publish_artifact / run.compare_results
+```
+
+内部全部映射到 `PydanticAI Toolset`，用户只见 `molexp` tool 名称。
+
+### 6.6 PydanticAI 事件映射
+
+| PydanticAI 内部事件 | Molexp 事件 |
+|---------------------|-------------|
+| Agent 开始规划 | `PlanCreatedEvent(plan_steps)` |
+| `FunctionToolCallEvent` | `ToolCallEvent(tool_name, args)` |
+| `FunctionToolResultEvent` | `ToolResultEvent(tool_name, result)` |
+| Agent 检测到失败，重规划 | `ReplanEvent(reason, new_plan)` |
+| `ApprovalRequiredToolset` 拦截 | `ApprovalRequestEvent(request_id, tool_name, args)` |
+| Agent `End` | `SessionCompletedEvent(summary, artifacts)` |
+
+---
+
+## 7. 彻底重构说明
+
+**删除的模块**：
+
+| 模块 | 替代 |
+|------|------|
+| `molexp.workflow.compiler.core` | `molexp.workflow.compiler.WorkflowGraphCompiler` |
+| `molexp.workflow.engine.engine` | `molexp.workflow.runtime.pydantic_graph` |
+| `molexp.workflow.task.Task` / `Actor` | `molexp.workflow.Step` / `Actor`（新 API） |
+| `molexp.workflow.workflow.Workflow` | `molexp.workflow.WorkflowSpec` |
+| `molexp.workflow.workflow.Link` | `StepContext.inputs` + `input_mapping` |
+
+**无向后兼容**：
+
+- 不保留旧 `Task`、`Link`、`WorkflowCompiler`、`WorkflowEngine` 的 import path
+- 不提供 shim 或 deprecation warning
+- 现有代码需按新 API 完整重写
+- 测试套件同步重写（旧测试直接删除，按新 API 重新覆盖）
+
+---
+
+## 8. 实施计划
+
+### Phase 1：彻底删除旧 kernel，定义新接口
+
+**目标**：清空自研 workflow runtime，定义新公共接口和内部 adapter contract。
+
+工作项：
+
+- **删除**：`workflow/compiler/`、`workflow/engine/`、旧 `workflow/task.py`、旧 `workflow/workflow.py`
+- 定义 `molexp.workflow` 新公共接口（`WorkflowSpec`、`Step`、`Actor`、`StepContext`、`ActorContext`、`workflow()` 装饰器、`WorkflowBuilder`）
+- 定义 `molexp.agent` 新公共接口（`Goal`、`AgentSession`、`AgentService`、`Tool`、`agent_tool`、`ApprovalPolicy`）
+- 定义内部 adapter interface（`WorkflowRuntime`、`AgentRuntime`、`ToolCatalogAdapter`、`RunStorePersistence`）
+- 按新接口重写 contract 测试（不测实现，只测接口行为）
+
+交付：新 API 类型定义冻结，旧 workflow 代码全部清除，新接口有 contract 测试。
+
+### Phase 2：接入 `PydanticAI`（Agent 层）
+
+**目标**：全量引入 agent/tool/session 层，不依赖 Phase 3 完成。
+
+工作项：
+
+- 实现 `PydanticAIAdapter`（封装 `pydantic_ai.Agent`）
+- 实现 `MolexpToolCatalog`（三层 tool → `PydanticAI Toolset`）
+- 接入 session event stream（PydanticAI 事件 → molexp 事件）
+- `ApprovalPolicy` + `ApprovalRequiredToolset` 集成
+- Session 持久化写入 workspace（`workspace/sessions/{session_id}/`）
+- UI：Session detail、Tool call timeline、Approval panel
+
+交付：`Goal → AgentSession → Tool Calls → Observations` 完整闭环，UI 可展示 session timeline。
+
+### Phase 3：用 `pydantic-graph` 实现 workflow runtime
+
+**目标**：实现新接口背后的 graph-backed runtime。
+
+工作项：
+
+- 实现 `WorkflowGraphCompiler`（`WorkflowSpec` → pydantic-graph 节点，支持函数式和 OOP 两种定义方式）
+- 实现 `RunStorePersistence`（`BaseStatePersistence` → Run store）
+- 实现 `GraphWorkflowRuntime`（Stable API 路径 + Beta API 路径）
+- 实现 `MultiActorRunner`（asyncio 并发 + 多 graph 实例）
+- UI：Workflow graph 可视化（pydantic-graph mermaid 输出）
+
+交付：`molexp.workflow` 新 API 完整可用，现有 workspace 测试全部通过。
+
+### Phase 4：产品化
+
+**目标**：Workflow + Agent 联合可视化，完整自主驱动体验。
+
+工作项：
+
+- Goal input UI
+- Session + Workflow runs 联合视图
+- Replanning 可视化
+- Human-in-the-loop approval flow
+- Session replay
+- Multi-session scheduling
+
+---
+
+## 9. 团队分工
+
+假设 8 人小组，角色分为三类：**产品与协调**、**工程**、**质量保障**。三条工程主线（Workspace、Workflow、Agent）并行推进，PM 和 QA 横切全程。
+
+### 角色总览
+
+| 角色 | 人数 | 主要职责 |
+|------|------|---------|
+| PM / Tech Lead | 1 | 产品目标、API 设计决策、跨成员协调、验收 |
+| QA Engineer | 1 | 测试策略、质量门控、集成测试、CI/CD |
+| Core & Workspace | 1 | 共享基础类型、workspace 稳定 |
+| Workflow API | 1 | 公共 workflow DSL（函数式 + OOP） |
+| Workflow Runtime | 1 | pydantic-graph adapter、MultiActorRunner |
+| Agent | 1 | PydanticAI 接入、session、tool |
+| Platform & UI | 2 | FastAPI 路由、React 前端 |
+
+---
+
+### PM / Tech Lead（1 人）
+
+**职责**：
+
+- **产品层**：维护并优先级排序 Phase 1-4 的功能列表；基于用户侧用例定义每个 Phase 的验收标准；决策 API 设计中的取舍（函数式 vs OOP 优先级、哪些能力纳入 MVP）
+- **技术协调**：主持每周接口评审会（Interface Review）；负责跨模块 API 冻结决策（尤其是 `StepContext`、`WorkflowRuntime` interface、`ToolContext` 等共享类型）；协调 B/C 之间的接口对齐
+- **验收**：每个 Phase 交付前，对照第 5 节"用户侧用例"逐条手工验证；记录 gap 并分派修复
+- **外部依赖追踪**：跟踪 pydantic-graph beta API 变更（release notes）；评估何时从 asyncio 多实例方案迁移到 beta 内建 pipeline
+
+**与其他角色的接口**：
+- 向 QA 输出每个 Phase 的验收测试场景清单
+- 向工程成员输出接口冻结通知（冻结后的变更需评审）
+- 接收 QA 的质量报告，决定是否 ready to release
+
+---
+
+### QA Engineer（1 人）
+
+**职责**：
+
+- **测试策略制定**（Phase 1）：定义三层测试金字塔——单元测试（各成员自持）、集成测试（QA 主持）、端到端测试（QA 主持）；制定覆盖率基线（unit ≥ 80%，集成测试覆盖所有跨层 API 路径）
+- **质量门控**：在 CI/CD 中配置 Phase 门控——每个 Phase 合并前必须通过全量测试；配置覆盖率检查、类型检查（mypy strict）、linting（ruff）
+- **集成测试主持**：负责编写并维护跨层集成测试：
+  - `WorkflowSpec → Run store 持久化` 全链路
+  - `Goal → AgentSession → Tool Calls → Run 产出` 全链路
+  - `Workspace 层级资产解析` 回归套件
+  - `MultiActorRunner` 并发安全专项测试（Actor 启动/消息/异常/关闭）
+- **端到端测试**：Phase 4 前建立 E2E 套件，覆盖第 5 节全部用户侧用例（含 UI 操作流）
+- **缺陷管理**：记录跨模块缺陷，协调 owner 修复；追踪 regression 率
+
+**与其他角色的接口**：
+- 接收 PM 输出的验收场景清单 → 转化为可执行测试用例
+- 向各工程成员输出单元测试模板和 mock 规范（避免各模块 mock 方式不一致）
+- 向 PM 输出每个 Phase 的质量报告（覆盖率、通过率、已知 bug）
+- 与成员 A 共同维护 workspace 层回归套件（此层变更最敏感）
+
+---
+
+### 成员 A：Core & Workspace（1 人）
+
+**负责模块**：`molexp.workspace`、`molexp.core`（基础类型、异常、注册表）
+
+**职责**：
+- 保持 workspace 层在重构期间稳定可用（是 Workflow 和 Agent 的依赖基础）
+- 定义 Phase 1 共享类型：`StepContext`、`ActorContext`、`ToolContext`、`RunStorePersistence` 接口（与 PM 对齐后冻结）
+- 实现 `RunStorePersistence`（写入 Run store 的原子逻辑）
+- workspace 层单元测试保持绿色；与 QA 共同维护回归套件
+
+**Phase 依赖**：Phase 1 最先启动，其他工程成员阻塞于共享类型定义。
+
+---
+
+### 成员 B：Workflow 公共 API（1 人）
+
+**负责模块**：`molexp.workflow`（公共 API 层）
+
+**职责**：
+- 定义 `WorkflowSpec`、`Step`（OOP 基类）、`Actor`（OOP 基类）
+- 实现 `workflow()` 装饰器、`WorkflowBuilder`、`parallel_map()`、`join()`、`@wf.actor`
+- 定义 `WorkflowExecution`、`WorkflowResult` 类型
+- 与成员 C 协作定义 `WorkflowRuntime` adapter interface（经 PM 评审后冻结）
+- 负责公共 API 层单元测试；向 QA 提供集成测试所需的 mock runtime
+
+**Phase 依赖**：Phase 1 完成后即可开始，与成员 C 并行。
+
+---
+
+### 成员 C：Workflow Runtime（1 人）
+
+**负责模块**：`molexp.workflow.runtime.pydantic_graph`、`MultiActorRunner`
+
+**职责**：
+- 实现 `WorkflowGraphCompiler`（`WorkflowSpec` → pydantic-graph 节点）
+- 实现 `GraphWorkflowRuntime`（Stable API + Beta API 双路径）
+- 实现 `MultiActorRunner`（asyncio 并发多 Actor pipeline）
+- Beta API 手动持久化适配（step 完成事件 → Run store 快照）
+- 单元测试覆盖各编译路径；Actor 并发场景交给 QA 做集成测试
+
+**Phase 依赖**：依赖成员 B 定义的 `WorkflowRuntime` interface（冻结后并行开发）。
+
+---
+
+### 成员 D：Agent 层（1 人）
+
+**负责模块**：`molexp.agent`、`molexp.agent.runtime.pydantic_ai`
+
+**职责**：
+- 实现 `PydanticAIAdapter`（封装 `pydantic_ai.Agent`）
+- 实现 `MolexpToolCatalog`（三层 tool → PydanticAI Toolset）
+- `ApprovalPolicy` + `ApprovalRequiredToolset` 集成
+- Session event stream 映射（PydanticAI 事件 → molexp 事件）
+- Session 持久化写入 workspace
+- `@agent_tool` 装饰器 + `Tool` OOP 基类
+- 单元测试可用 mock workspace 隔离；端到端 Agent 场景交给 QA
+
+**Phase 依赖**：Phase 2，可与成员 C 完全并行。
+
+---
+
+### 成员 E/F：Platform & UI（2 人）
+
+**负责模块**：`molexp.server`（FastAPI）、`ui/`
+
+**职责分工**：
+
+- **成员 E（Backend Platform）**：FastAPI 路由（`/api/workflow/*`、`/api/agent/*`）；OpenAPI → TypeScript codegen 维护；WebSocket / SSE for session event stream；与 B/C/D 协作接口联调
+- **成员 F（Frontend）**：Session detail、Tool call timeline、Approval panel（Phase 2）；Workflow graph 可视化（Phase 3）；Goal input UI、联合视图（Phase 4）
+
+**Phase 依赖**：横切所有 Phase，随其他成员交付逐步推进。
+
+---
+
+### 并行关系与里程碑
+
+```
+         Week 1-2          Week 3-6           Week 7-10         Week 11+
+         ──────────────────────────────────────────────────────────────
+PM:      [接口评审+API冻结决策]─────[Phase验收]──[Phase验收]──[Phase验收]──
+QA:      [测试策略+CI配置]──[集成测试套件]───[E2E套件]────────[质量报告]────
+A:       [共享类型+Workspace稳定]─────────────────────────────────────────
+B:       [Phase 1: Workflow公共API]──[Phase 3: DSL完善]───────────────────
+C:                  [Phase 3: Graph Adapter + MultiActorRunner]───────────
+D:            [Phase 2: PydanticAI Agent层]──────────────────────────────
+E:       [路由skeleton]──[Phase 2: 后端API]──[Phase 3: API扩展]──[Phase 4]
+F:       [UI框架]────────[Phase 2: Session UI]─[Phase 3: Graph UI]─[Phase 4]
+                                                              ↓
+                                                     [Phase 4: 产品化]
+```
+
+**关键依赖链**：
+
+1. A 先于所有人完成共享类型冻结（`StepContext`、`RunStorePersistence` 接口）
+2. PM 评审 B/C 的 `WorkflowRuntime` interface → 冻结 → C 才能全速推进
+3. D 完全独立，与 B/C 并行
+4. QA 在 Phase 1 末建好 CI 质量门控，阻断不合格的 Phase 合并
+
+**接口冻结协议**：所有跨模块共享类型（`StepContext`、`WorkflowRuntime`、`ToolContext` 等）需经 PM 主持的 Interface Review 会议冻结；冻结后变更需重新评审，由 PM 决策影响范围。
+
+---
+
+## 10. 风险与缓解
+
+### 10.1 Beta API 无持久化
+
+风险：并行扇出 workflow 无内建快照，进程崩溃后无法恢复。
+
+缓解：adapter 层在每个 step 完成事件后主动写 state 快照到 Run store，用户无感知。
+
+### 10.2 pydantic-graph API 演进
+
+风险：Beta API 仍在演化，接口可能变更。
+
+缓解：所有 pydantic-graph 调用隔离在 `molexp.workflow.runtime.pydantic_graph` 内部，对外只暴露 `molexp` 类型。未来切换只改 adapter 实现。
+
+### 10.3 多 Actor Pipeline 并发安全
+
+风险：`MultiActorRunner` 逻辑复杂，难以调试。
+
+缓解：写专项集成测试，覆盖 Actor 启动、消息传递、异常传播、优雅关闭。Beta API 未来如加入 pipeline 模式，可替换实现而不改用户接口。
+
+### 10.4 彻底删除旧 kernel 的回归风险
+
+风险：删除 `WorkflowCompiler` / `WorkflowEngine` 后，现有高层测试可能大量失败。
+
+缓解：Phase 1 同步删除旧测试，按新 API contract 重写，不试图让旧测试通过新实现。workspace 层测试（不依赖 workflow runtime）保持绿色作为回归防线。
+
+---
+
+## 11. 成功标准
+
+- 用户只使用 `molexp` API，不直接依赖 `pydantic_ai` 或 `pydantic_graph` 类型
+- `workspace` 仍然是唯一产品真相源
+- Workflow 支持函数式和 OOP 两种风格，底层编译路径统一
+- `PydanticAI` 完整承载 `molexp.agent`（goal → session → tools → observations）
+- `pydantic-graph` 完整承载 `molexp.workflow` runtime（BATCH + 并行扇出 + Actor 循环）
+- workflow run / agent session / assets 能统一出现在同一产品视图中
+- workspace / run / asset 测试全部通过
+- 用户可以用 5 行代码给一个 goal，得到一个完整的实验结果
+
+---
+
+## 12. 参考资料
+
+- pydantic-graph Overview：https://ai.pydantic.dev/graph/
+- pydantic-graph Graph API：https://ai.pydantic.dev/api/pydantic_graph/graph/
+- pydantic-graph Persistence API：https://ai.pydantic.dev/api/pydantic_graph/persistence/
+- pydantic-graph Beta：https://ai.pydantic.dev/graph/beta/
+- pydantic-graph Beta API：https://ai.pydantic.dev/api/pydantic_graph/beta/
+- PydanticAI Agents：https://ai.pydantic.dev/agent/
+- PydanticAI Toolsets：https://ai.pydantic.dev/toolsets/
+- PydanticAI UI Overview：https://ai.pydantic.dev/ui/overview/
+- PydanticAI Durable Execution：https://ai.pydantic.dev/durable_execution/overview/
diff --git a/docs/get-started/quick-start.md b/docs/get-started/quick-start.md
index eeaefc84..9ebc3659 100644
--- a/docs/get-started/quick-start.md
+++ b/docs/get-started/quick-start.md
@@ -1,205 +1,156 @@
 # Quick Start
 
-Let's create a complete MolExp workflow in five minutes, from defining tasks to execution, experiencing MolExp's complete workflow.
+Let's build a complete MolExp workflow in five minutes — from defining tasks to execution and workspace tracking.
 
-## Step 1: Define Your First Task
+## Step 1: Define Tasks
 
-A Task is the most basic computation unit in MolExp. Each task needs to inherit from the `Task` base class, specify a configuration type, and implement the `execute` method.
-
-What is a task? A task is a pure functional computation unit that accepts outputs from upstream tasks as inputs, performs computation, and produces outputs. Task configuration is determined at construction time, ensuring task behavior is predictable and serializable.
-
-Why this design? Static configuration allows us to validate configuration correctness before execution and enables complete workflow serialization. This is crucial for reproducibility.
-
-Let's create a simple task that receives a number and returns its square:
+A **Task** is the basic computation unit. Subclass `Task` and implement `execute()`. The `TaskContext` gives you access to upstream outputs, shared state, and workspace capabilities.
 
 ```python
-from molexp.workflow.node import Task
-from pydantic import BaseModel
-
-class SquareConfig(BaseModel):
-    """Configuration model defining task parameters"""
-    pass  # This task doesn't need extra configuration
-
-class SquareTask(Task[SquareConfig, int]):
-    """Compute the square of an input number"""
-    config_type = SquareConfig
-    
-    def execute(self, value: int) -> int:
+from molexp.workflow import Task, TaskContext
+
+class SquareTask(Task):
+    async def execute(self, ctx: TaskContext) -> float:
+        value: float = ctx.inputs
         return value * value
 ```
 
-## Step 2: Connect Tasks to Build a Workflow
+For streaming tasks, use `Actor` with `run()` instead.
+
+## Step 2: Compose a Workflow
 
-Now let's create multiple tasks and connect them. Suppose we want to square a number, then add 10:
+Two equivalent styles are available.
+
+**Functional DSL** (for inline definitions):
 
 ```python
-class AddConfig(BaseModel):
-    offset: int = 10
-
-class AddTask(Task[AddConfig, int]):
-    config_type = AddConfig
-    
-    def execute(self, value: int) -> int:
-        return value + self.config.offset
-
-# Create task instances and establish dependencies
-square = SquareTask(task_id="square")
-add = AddTask(square, task_id="add", offset=10)
-```
+from molexp.workflow import workflow, TaskContext
 
-Note that `AddTask`'s first parameter is `square`, indicating that `add` depends on `square`'s output. This declarative dependency relationship makes the workflow structure clear at a glance.
+wf = workflow(name="pipeline")
 
-## Step 3: Register and Execute Tasks
+@wf.task
+async def square(ctx: TaskContext) -> float:
+    return ctx.inputs ** 2
 
-To execute tasks in a workflow, you need to register them with the task registry. The registry allows the execution engine to find and instantiate your tasks:
+@wf.task(depends_on=["square"])
+async def add_bias(ctx: TaskContext) -> float:
+    return ctx.inputs + 10.0
+
+spec = wf.build()
+```
+
+**OOP builder** (for reusable task classes):
 
 ```python
-from molexp.ir.registry import registry
-
-# Register tasks with the registry
-@registry.register("square", SquareConfig)
-class SquareTask(Task[SquareConfig, int]):
-    config_type = SquareConfig
-    
-    def execute(self, value: int) -> int:
-        return value * value
+from molexp.workflow import Task, WorkflowBuilder, TaskContext
+
+class SquareTask(Task):
+    async def execute(self, ctx: TaskContext) -> float:
+        return ctx.inputs ** 2
+
+class AddBiasTask(Task):
+    async def execute(self, ctx: TaskContext) -> float:
+        return ctx.inputs + 10.0
 
-@registry.register("add", AddConfig)
-class AddTask(Task[AddConfig, int]):
-    config_type = AddConfig
-    
-    def execute(self, value: int) -> int:
-        return value + self.config.offset
+spec = (
+    WorkflowBuilder(name="pipeline")
+    .add(SquareTask())
+    .add(AddBiasTask(), depends_on=["square"])
+    .build()
+)
 ```
 
-Once tasks are registered, you can execute them directly or use them in workflows. For simple cases, you can call tasks directly:
+## Step 3: Execute
 
 ```python
-# Execute tasks directly
-square = SquareTask(task_id="square")
-result = square(5)  # Returns 25
+import asyncio
+
+async def main():
+    result = await spec.execute()
+    print(result)
 
-add = AddTask(square, task_id="add", offset=10)
-final_result = add(5)  # Returns 35 (square(5) + 10)
+asyncio.run(main())
 ```
 
-For more complex workflows with multiple tasks and dependencies, you'll typically use the workspace API or load workflows from JSON files. The workflow compilation and execution happens automatically behind the scenes.
+Same-level tasks run in parallel automatically — no extra configuration needed.
 
-## Step 4: Use Workspace to Manage Experiments
+## Step 4: Track with Workspace
 
-In real scientific computing scenarios, we usually need to manage multiple experiments and runs. MolExp provides a complete workspace architecture:
+In real scientific workflows you want reproducibility, artifact tracking, and parameter sweeps. MolExp's workspace layer handles all of that.
 
 ```python
-from molexp.workspace.core import Workspace
-from molexp.workflow.context import RunContext, use_run_context
-from molexp.assets import AssetRepo
+from molexp.workspace import Workspace
 
-# Create workspace
-workspace = Workspace.from_path("./my_workspace")
+# Create workspace (side-effect-free until materialize())
+workspace = Workspace.from_path("./lab")
 
-# Create project
-project = workspace.create_project(
-    id="my_project",
-    name="My Research Project",
-)
+# Hierarchical API
+project = workspace.create_project(name="My Research Project")
+experiment = project.create_experiment(name="Experiment 1")
+run = experiment.create_run(parameters={"lr": 0.01, "epochs": 10})
 
-# Create experiment
-experiment = workspace.create_experiment(
-    id="my_project",
-    id="exp_1",
-    name="First Experiment",
-    workflow_source="workflow.py",
-)
+# Attach a run when executing so outputs are tracked automatically.
+# Pass dry_run=True to expose ctx.dry_run inside tasks.
+result = await spec.execute(run=run, dry_run=True)
+```
 
-# Create run
-run = workspace.create_run(
-    id="my_project",
-    id="exp_1",
-    parameters={"input_value": 5},
-    workflow_file="workflow.py",
-)
+Inside tasks, access workspace capabilities via `ctx`:
 
-# Use run context during execution
-ctx = RunContext(
-    asset_repo=AssetRepo(),
-    id=run.id,
-    run_metadata=run,
-    workspace=workspace,
-)
+```python
+class TrainTask(Task):
+    async def execute(self, ctx: TaskContext) -> dict:
+        if ctx.dry_run:
+            return {"loss": None, "mode": "dry-run"}
 
-with use_run_context(ctx):
-    # Execute your workflow here
-    # Workflows are typically loaded from files or defined via the API
-    # All registered assets will be automatically tracked
-    pass
-```
+        model = train(ctx.inputs, **ctx.state)
+
+        # Save artifact to run directory
+        ctx.save_artifact("model.pt", model)
 
-## Complete Example
+        # Find a pre-registered asset up the scope hierarchy
+        dataset = ctx.find_asset("training_data")
+
+        return {"loss": 0.05}
+```
 
-Here's a complete runnable example showing the full flow from task definition to execution:
+## Complete Runnable Example
 
 ```python
-from molexp.workflow.node import Task
-from molexp.ir.registry import registry
-from molexp.workspace.core import Workspace
-from molexp.workflow.context import RunContext, use_run_context
-from molexp.assets import AssetRepo
-from pydantic import BaseModel
-
-# Define configuration models
-class SquareConfig(BaseModel):
-    pass
-
-class AddConfig(BaseModel):
-    offset: int = 10
-
-# Register and define tasks
-@registry.register("square", SquareConfig)
-class SquareTask(Task[SquareConfig, int]):
-    config_type = SquareConfig
-    
-    def execute(self, value: int) -> int:
-        return value * value
+import asyncio
+from molexp.workflow import workflow, TaskContext
+from molexp.workspace import Workspace
+
+wf = workflow(name="demo")
+
+@wf.task
+async def fetch(ctx: TaskContext) -> list[float]:
+    return [1.0, 4.0, 9.0]
+
+@wf.task(depends_on=["fetch"])
+async def compute(ctx: TaskContext) -> float:
+    return sum(ctx.inputs)
+
+spec = wf.build()
+
+async def main():
+    # Pure computation (no workspace)
+    result = await spec.execute()
+    print(f"Result: {result}")
+
+    # With workspace tracking
+    workspace = Workspace.from_path("./lab")
+    project = workspace.create_project(name="Demo")
+    experiment = project.create_experiment(name="Run 1")
+    run = experiment.create_run(parameters={})
+
+    result = await spec.execute(run=run, dry_run=True)
+    print(f"Result (tracked): {result}")
 
-@registry.register("add", AddConfig)
-class AddTask(Task[AddConfig, int]):
-    config_type = AddConfig
-    
-    def execute(self, value: int) -> int:
-        return value + self.config.offset
-
-def main():
-    # Create tasks and execute directly
-    square = SquareTask(task_id="square")
-    add = AddTask(square, task_id="add", offset=10)
-    
-    # Execute
-    result = add(5)
-    print(f"Result: {result}")  # (5^2) + 10 = 35
-    
-    # Or use with workspace for full tracking
-    workspace = Workspace.from_path("./workspace")
-    project = workspace.create_project("demo", name="Demo")
-    experiment = workspace.create_experiment(
-        "demo", "exp_1", "Experiment 1", "workflow.py"
-    )
-    run = workspace.create_run("demo", "exp_1", {}, "workflow.py")
-    
-    ctx = RunContext(
-        asset_repo=AssetRepo(),
-        id=run.id,
-        run_metadata=run,
-        workspace=workspace,
-    )
-    
-    with use_run_context(ctx):
-        result = add(5)
-        print(f"Result with context: {result}")
-
-if __name__ == "__main__":
-    main()
+asyncio.run(main())
 ```
 
-For advanced workflow definitions using IR models and compilation, see the [Developer Documentation](developer/ir-and-compiler.md).
+## Next Steps
 
-Congratulations! You've completed your first MolExp workflow. In the following chapters, we'll explore the design details and advanced usage of each component.
+- [Task reference](../core/task.md) — full Task and Actor API
+- [Workspace architecture](../workspace/) — projects, experiments, assets
+- [Developer docs](../developer/) — internal compiler and IR details
diff --git a/docs/index.md b/docs/index.md
index f32c20ae..ce00fabf 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,97 +1,119 @@
 # MolExp Documentation
 
-Welcome to MolExp! A tiny yet fully-typed task-graph framework built on top of Pydantic, designed for scientific computing workflows. MolExp provides a pure functional task abstraction, a static compiler that produces deterministic graph orders, a runtime engine, and a tiny DSL for common data-flow patterns.
+Welcome to MolExp — a workflow-and-agent platform for research experiment management. MolExp provides a typed task-graph framework, a three-tier workspace hierarchy (Project → Experiment → Run), content-addressed asset storage, and a FastAPI server with React UI.
 
 ## Why MolExp?
 
-MolExp's design philosophy is "minimal yet complete". We believe a good framework should make every component's role clear and visible, without hidden magic. Therefore, MolExp's codebase stays lean, with each layer having explicit responsibilities, allowing you to fully understand how workflows are compiled and executed.
+MolExp's design philosophy is "minimal yet complete". Every layer has explicit responsibilities with no hidden magic:
 
-MolExp is particularly suited for scientific computing scenarios that require reproducibility, traceability, and extensibility. Whether it's molecular dynamics simulations, machine learning training, or data analysis pipelines, MolExp helps you organize code, manage dependencies, and track results.
+- **Workflow layer**: DAG-based task graphs compiled from Python with automatic parallelization
+- **Agent layer**: Goal-driven autonomous execution on top of PydanticAI
+- **Workspace layer**: File-system-backed experiment management with full reproducibility
+- **Server + UI**: FastAPI backend and React frontend for browsing experiments and results
 
-MolExp exposes a protocol interface for in-process compatibility, but persisted workflows require `Task` classes with Pydantic configurations and explicit registration. This keeps workflows deterministic and replayable.
+MolExp is particularly suited for scientific computing scenarios that require reproducibility, traceability, and extensibility — molecular dynamics, ML training, data analysis pipelines, and more.
 
-## Core Architecture
+## Architecture
 
-MolExp's architecture consists of three core layers:
+```
+WorkflowSpec → Runtime → Workspace → FastAPI → React UI
+                             ↑
+                      AgentService (PydanticAI)
+```
 
 <div class="grid cards" markdown>
 
--   :material-code-tags: **Task Abstraction**
+-   :material-graph: **Workflow Layer**
 
     ---
 
-    **Pure Functional Task Definition**
-    
-    Each task is an independent computation unit with type-safe configuration via Pydantic models. Persisted workflows use explicit registration and deterministic task IDs.
-    
-    [:octicons-arrow-right-24: Learn about Tasks](core/task.md)
+    **DAG-based task graphs**
 
--   :material-compile: **Compiler Layer**
+    Define tasks with the functional DSL (`@wf.task`) or OOP builder. The runtime automatically parallelizes independent tasks.
+
+    [:octicons-arrow-right-24: Quick Start](get-started/quick-start.md)
+
+-   :material-robot: **Agent Layer**
 
     ---
 
-    **Static Graph Compilation**
-    
-    The compiler statically analyzes task graphs, generates deterministic execution orders, and detects circular dependencies.
-    
-    [:octicons-arrow-right-24: Developer Docs](developer/ir-and-compiler.md)
+    **Goal-driven autonomous execution**
 
--   :material-play: **Execution Engine**
+    `AgentService` wraps PydanticAI to provide tool approval, streaming events, and workspace-aware session management.
+
+-   :material-folder-multiple: **Workspace Layer**
 
     ---
 
-    **Parallel Execution & Failure Propagation**
-    
-    The engine supports parallel execution of independent tasks, automatic failure propagation, and execution hooks for monitoring.
-    
-    [:octicons-arrow-right-24: Learn about Engine](core/engine.md)
+    **Project → Experiment → Run hierarchy**
+
+    Each level owns an `AssetLibrary` for scoped, content-addressed artifact storage. All metadata writes are atomic.
+
+    [:octicons-arrow-right-24: Workspace Docs](workspace/)
+
+-   :material-server: **Server + UI**
+
+    ---
+
+    **FastAPI + React**
+
+    All routes under `/api`. The React UI provides a three-panel experiment browser. TypeScript client is auto-generated from `openapi.json`.
 
 </div>
 
-## Workspace Architecture
+## Core Concepts
 
-MolExp provides a complete Project-Experiment-Run three-tier architecture to help you organize and manage scientific computing workflows:
+### Tasks and Actors
 
-<div class="grid cards" markdown>
+| Type | Base class | Method | Use for |
+|------|-----------|--------|---------|
+| Batch | `Task` | `async execute(ctx)` | single-pass computation |
+| Streaming | `Actor` | `async run(ctx)` (generator) | continuous / event-driven |
 
--   :material-folder: **Project**
+### Workflow Definition
 
-    ---
+Two equivalent styles:
 
-    **Top-level container for research areas**
-    
-    A project represents a research domain or topic, containing multiple experiments.
-    
-    [:octicons-arrow-right-24: Learn about Workspace](workspace/architecture.md)
+```python
+# Functional DSL
+wf = workflow(name="pipeline")
 
--   :material-flask: **Experiment**
+@wf.task
+async def fetch(ctx: TaskContext) -> list[float]: ...
 
-    ---
+@wf.task(depends_on=["fetch"])
+async def process(ctx: TaskContext) -> float: ...
 
-    **Repeatable workflow definitions**
-    
-    Experiments define repeatable workflow templates with parameter space definitions.
-    
-    [:octicons-arrow-right-24: Learn about Workspace](workspace/architecture.md)
+spec = wf.build()
+```
 
--   :material-play-circle: **Run**
+```python
+# OOP builder
+spec = (
+    WorkflowBuilder(name="pipeline")
+    .add(FetchTask())
+    .add(ProcessTask(), depends_on=["fetch"])
+    .build()
+)
+```
 
-    ---
+### Workspace Hierarchy
 
-    **Single execution instance**
-    
-    A run is a concrete execution of an experiment, containing complete reproducibility information.
-    
-    [:octicons-arrow-right-24: Learn about Workspace](workspace/architecture.md)
+```python
+workspace = Workspace.from_path("./lab")
+project    = workspace.create_project(name="MD Simulations")
+experiment = project.create_experiment(name="Temperature Sweep")
+run        = experiment.create_run(parameters={"T": 300})
 
-</div>
+result = await spec.execute(run=run)
+```
 
 ## Quick Start
 
-If you're new to MolExp, we recommend starting with the quick start guide, which will walk you through creating and executing your first workflow.
+New to MolExp? Start here:
 
-[:octicons-arrow-right-24: Get Started](get-started/quick-start.md)
+[:octicons-arrow-right-24: Quick Start Guide](get-started/quick-start.md)
 
 ## License
 
-MIT License - see [LICENSE](https://github.com/molcrafts/molexp/blob/main/LICENSE) for details.
+BSD 3-Clause License — see [LICENSE](https://github.com/molcrafts/molexp/blob/main/LICENSE) for details.
diff --git a/docs/spec/fullscreen-monitor.md b/docs/spec/fullscreen-monitor.md
new file mode 100644
index 00000000..874ab95b
--- /dev/null
+++ b/docs/spec/fullscreen-monitor.md
@@ -0,0 +1,257 @@
+# Spec: Full-screen Run Monitor for Molexp, Powered by Molq Panels
+
+## Goal
+
+为 `molexp` 设计一个全屏终端 monitor，用于观察本地或远程任务的运行状态。
+
+该 monitor 的体验目标类似 `htop` / `btop`：不是简单打印一张表，而是一个**占满终端的 dashboard**，包含顶部 overview、进度展示、底部任务列表，以及基本的交互关闭/重开能力。
+
+该设计明确以下边界：
+
+- 界面如何组织
+- `molq` 插件负责什么
+- `molexp` 负责什么
+- 两者如何协作
+- 哪些是必须满足的交互需求
+
+本 spec 只定义**产品与架构需求**，不规定具体代码结构、类名或实现方式。
+
+---
+
+## Design Principles
+
+### 1. Full-screen monitor, not inline table
+
+当前的小 panel + 单个表格形式不可接受。monitor 必须是一个完整终端视图，视觉和交互都应接近系统监控工具，而不是 CLI 的一次性文本输出。
+
+### 2. Overview-first, list-second
+
+最重要的信息不是单行任务表，而是整体状态。界面必须优先展示：
+
+- 当前是否在运行
+- 总体进度
+- running / pending / done / failed 的总体数量
+- 当前 workflow / run 的整体状态
+
+任务列表作为下半部分内容，而不是整个界面的核心。
+
+### 3. Single-job and multi-job must both look natural
+
+即使只有 1 个 job，也不应退化成一张尴尬的小表。同一套 full-screen monitor 应同时适用于单任务、多任务 sweep、本地运行、远程调度运行。
+
+### 4. Status-first, table-second
+
+状态必须是界面中的第一视觉锚点。用户应一眼看到 running / pending / done / failed，而不是先看 run id 或 scheduler id。
+
+### 5. Monitor is a viewer, not the run itself
+
+关闭 monitor 不应终止运行。monitor 是观察界面，不是任务本体。
+
+---
+
+## UI Requirements
+
+### Overall Layout
+
+monitor 占用整个 terminal，包含以下三个区域：
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  A. Header / Title Area                                 │
+│  workflow name · overall status · last updated          │
+├───────────────────────────────┬─────────────────────────┤
+│  B. Overview Area             │                         │
+│  total · running · pending    │   progress bar / vis    │
+│  done · failed                │                         │
+├───────────────────────────────┴─────────────────────────┤
+│  C. Job List Area                                       │
+│  state · run identity · scheduler id · elapsed ...      │
+│  ...                                                    │
+├─────────────────────────────────────────────────────────┤
+│  D. Footer / Hint Area        q: quit  r: refresh  ...  │
+└─────────────────────────────────────────────────────────┘
+```
+
+### A. Header / Title Area
+
+展示 monitor 的身份信息和当前整体状态。至少包含：
+
+- 当前 workflow / run / experiment 的标识
+- 当前整体状态（running / finished / failed / mixed）
+- 最近更新时间或刷新时间
+
+### B. Overview Area
+
+界面的核心，位于上半部分。至少展示：
+
+- 总任务数
+- running / pending / done / failed 数量
+- 整体进度（必须有明确可读的 progress visualization，例如进度条）
+
+进度不能只是 `0/1 done` 这种弱表达，必须有更强的 overview 感知。
+
+### C. Job List Area
+
+位于下半部分，展示每个 job / run 的状态。每条目至少包含：
+
+- state
+- run identity
+- scheduler id（如有）
+- 其他次要元信息（elapsed、node、message 等由 agent 自行判断）
+
+列表服务于"快速扫状态"，而不是做数据库式大表格。
+
+### D. Footer / Hint Area
+
+界面底部保留简洁的交互提示区域。至少提示：
+
+- `q` 关闭 monitor
+- 其他交互提示由 agent 自行设计
+
+---
+
+## Visual Requirements
+
+### 1. Avoid heavy boxed table aesthetics
+
+不接受"一个 panel 里套一张 box-heavy 表格"的风格。减少无意义边框，强调分区、状态和进度。
+
+### 2. Strong visual status hierarchy
+
+状态必须有明显视觉区分。颜色、图标、位置和文本都应服务于快速识别。
+
+### 3. Scheduler ID is secondary
+
+`scheduler id` 不是第一重要信息，不应压过状态和 run identity。
+
+### 4. Progress must be visually central
+
+overview 中必须有明确的 progress visualization。这不是可选增强，而是 monitor 的核心组成。
+
+---
+
+## Interaction Requirements
+
+### 1. `q` closes the monitor
+
+用户按 `q` 时，关闭 full-screen monitor，返回普通 CLI。
+
+### 2. Closing the monitor must not cancel jobs
+
+`q` 的语义只能是 close viewer / quit monitor / return to normal CLI。绝不能终止远程任务、本地 workflow 或 scheduler jobs。
+
+### 3. Monitor must be reopenable
+
+关闭后，用户必须能通过显式命令再次打开 monitor。命名不强制，但 monitor 不是一次性的，必须可重复进入。
+
+### 4. Run command and watch command should cooperate naturally
+
+如果 `run` 命令在提交后自动进入 monitor，退出 monitor 后应能回到普通 CLI，并给出明确提示：
+
+- 任务仍在继续
+- 用户可以再次打开 monitor
+
+---
+
+## Molexp vs Molq Responsibilities
+
+### Molexp responsibilities
+
+`molexp` 是 workflow / run orchestration 层，负责：
+
+- 决定何时进入 monitor，何时退出 monitor
+- 管理 monitor 的打开 / 关闭 / 重新打开
+- 管理 run / workflow / experiment 的生命周期
+- 收集和整理运行状态数据
+- 将运行状态转换成 monitor 所需的通用状态输入
+- 在 CLI 流程中决定 monitor 与普通输出之间如何切换
+
+**`molexp` 拥有 monitor 的生命周期控制权。**
+
+### Molq responsibilities
+
+`molq` 插件负责 monitor 的**界面能力**，而不是 workflow 生命周期。它负责：
+
+- 提供 full-screen panel / dashboard 能力
+- 提供 overview 区域和 job list 区域的界面表达
+- 提供 monitor 的交互语义解释
+- 提供可复用的 terminal viewer 体验
+
+`molq` 不主导任务生命周期，不决定 run 是否结束、是否继续提交等 workflow 语义。
+
+### Interaction contract between Molexp and Molq
+
+| 职责 | 归属 |
+|------|------|
+| monitor 何时创建、关闭、重新进入 | molexp |
+| monitor 如何呈现、基本交互 UI 语义 | molq |
+| workflow 是否结束、是否继续提交 | molexp |
+| Rich 布局细节、panel 组件 | molq |
+| UI 交互结果转化为 CLI/生命周期动作 | molexp |
+
+规则：
+
+1. **Molexp owns control flow** — `molexp` 控制 monitor 生命周期
+2. **Molq owns presentation semantics** — `molq` 提供 monitor 如何呈现
+3. **Molq must not own workflow lifecycle** — `molq` 不自己决定"停止任务""终止 workflow"
+4. **Molexp must not reimplement panel logic** — `molexp` 不应自己硬写所有 Rich 布局，否则 `molq` 作为 panel/plugin 层失去意义
+5. **UI actions must be interpretable by Molexp** — monitor 中的交互结果应能被 `molexp` 接住并转化为 CLI/生命周期动作
+
+---
+
+## Architectural Constraints
+
+1. **No giant monolithic CLI table renderer** — 不接受把所有逻辑直接写成单个 CLI 输出函数
+2. **No inversion of control from Molq into Molexp lifecycle** — `molq` 不能反过来控制 `molexp` 的主流程
+3. **No scheduler-specific UI hardcoding** — UI 不应被 slurm/pbs/lsf 某一种调度器结构绑死；monitor 应围绕 run/job 状态设计
+4. **UI design should scale from local to remote** — 同一套 monitor 应同时服务于 local、remote、scheduler-backed runs
+
+---
+
+## Agent Tasks
+
+agent 需要基于当前 codebase 设计并实现：
+
+1. 一套 full-screen terminal monitor 的信息架构
+2. 单任务和多任务都自然的界面组织方式
+3. `molexp` 与 `molq` 之间的职责边界与接口契约
+4. monitor 打开、关闭、重新打开的交互流程
+5. 能够支撑 future remote backends 的状态模型
+
+agent 自行决定：
+
+- 具体布局组件
+- 具体 Rich 组织方式（layout / panel / live / screen 等）
+- 具体交互键位集合
+- 具体 state object / panel object / plugin object 设计
+
+---
+
+## Acceptance Criteria
+
+| 要求 | 类别 |
+|------|------|
+| monitor 是 full-screen dashboard，而不是小 panel | UI |
+| 上半部分有清晰 overview 和进度展示 | UI |
+| 下半部分有 job list | UI |
+| 状态比表格列更重要，视觉上优先 | Visual |
+| 单任务场景也自然，不退化 | UI |
+| `q` 只关闭 monitor，不取消运行 | Interaction |
+| monitor 可重新打开 | Interaction |
+| `molq` 负责 panel/view 能力 | Architecture |
+| `molexp` 负责 monitor 生命周期与 CLI 切换 | Architecture |
+| 两者职责清晰，不互相吞没 | Architecture |
+
+---
+
+## Non-goals
+
+本 spec 不要求：
+
+- 具体类设计或函数签名
+- 具体键盘事件实现方式
+- 具体 scheduler adapter 代码
+- 具体 Rich API 写法
+- 完整 TUI 框架抽象
+
+这些由 agent 根据 codebase 自行判断和设计。
diff --git a/docs/spec/molcfg-profiles.md b/docs/spec/molcfg-profiles.md
new file mode 100644
index 00000000..2e9b10e1
--- /dev/null
+++ b/docs/spec/molcfg-profiles.md
@@ -0,0 +1,213 @@
+# molcfg + Profiles: 配置文件与 Profile 机制
+
+**状态**: Draft · **作者**: @RoyKid · **日期**: 2026-04-13
+
+## 1. 动机
+
+当前 `--dry-run` 是硬编码的一等执行模式，扎根于 CLI、RunStatus、RunMetadata、
+ExecutionConfig、ctx、UI badge 等多层。进一步的需求（`--profile smoke`、
+`--dataset-md17`、速度测试、debug 切片）会让 CLI 快速膨胀为 CMake 式的
+flag 森林。
+
+**目标**: 用单一机制——带命名 profile 的配置文件——覆盖所有参数变体
+（dataset、epochs、batch_size、dry-run 是否跳过重计算、...）。
+
+**Profile 语义对框架透明**: 框架只负责"加载配置 / 选中切片 / 注入 ctx /
+记录 profile 名到 run metadata"。切片里写什么字段、task 如何解读它们
+（包括"是否产生持久化副作用"），完全由用户自己定义。框架不内置任何
+语义字段（没有 `side_effects`、没有 `real`、没有 `persist`）。
+
+**非目标**: 向后兼容 `ctx.dry_run` / `RunStatus.DRY_RUN` / `--dry-run` 作为
+独立字段。全部替换，无 deprecation 期。
+
+## 2. 设计原则
+
+1. **CLI 稳定**: `molexp run script.py [--config X.yaml] [--profile NAME]` 是
+   唯一入口；新增变体只改 config，不改 CLI。
+2. **Profile 是命名的配置切片**: profile 名本身就是 UI 展示标签、run
+   metadata 字段、resume 过滤条件。
+3. **框架对 profile 内容不可知**: 任何字段都是用户数据。Task 代码通过
+   `ctx.config["epochs"]` 等自由读取。框架不解释。
+4. **Profile 名归一化**: `-` 自动替换为 `_`（YAML 里 `dry-run` 等价于
+   `dry_run`），避免 Python 标识符场景和 CLI 下划线/连字符混淆。
+5. **格式**: YAML（默认）或 JSON。不支持 TOML（stdlib 只读）。
+6. **Profile 可继承**: 显式 `extends: NAME`，不用 YAML anchor（JSON 写不出、
+   魔法多）。
+
+## 3. Schema 草案
+
+### 3.1 配置文件
+
+```yaml
+# molcfg.yaml
+version: 1
+
+# 默认值（所有 profile 继承）
+defaults:
+  dataset: md17
+  epochs: 100
+  batch_size: 32
+  seed_base: 42
+
+profiles:
+  dry-run:                # 加载时归一化为 "dry_run"
+    extends: defaults
+    epochs: 1
+
+  smoke:
+    extends: defaults
+    epochs: 5
+    batch_size: 8
+
+  md22:
+    extends: defaults
+    dataset: md22
+
+  prod:
+    extends: defaults
+    # 显式空，等同 defaults
+```
+
+### 3.2 Pydantic 模型
+
+```python
+# src/molexp/config/models.py
+class ProfileConfig(Mapping[str, Any]):
+    """Immutable merged config for one profile.
+
+    Behaves like a read-only dict of user data; carries a ``name`` attr
+    (normalized, "-" → "_"; ``None`` means "no profile, defaults only").
+    Framework adds no semantic fields — every key comes from the YAML.
+    """
+    name: str | None
+    # internal: frozen dict
+
+    def __getitem__(self, key: str) -> Any: ...
+    def get(self, key: str, default=None) -> Any: ...
+    def hash(self) -> str: ...  # content-hash for RunMetadata.config_hash
+
+class MolCfg(BaseModel, frozen=True):
+    version: int = 1
+    defaults: dict[str, Any] = Field(default_factory=dict)
+    profiles: dict[str, dict[str, Any]] = Field(default_factory=dict)
+
+    def resolve(self, name: str | None) -> ProfileConfig:
+        """Merge defaults + (optional) profile; normalize name; freeze."""
+```
+
+### 3.3 Context 注入
+
+```python
+class StepContext(Generic[StateT, DepsT, InputT]):
+    config: ProfileConfig   # 新增
+    # 移除 dry_run 属性
+```
+
+Task 作者的 migration（任何"跳过副作用"的判断都变成用户自己的 config 字段）：
+```python
+# 旧
+if ctx.dry_run:
+    return mock_result()
+
+# 新 —— 用户自己在 YAML 里加字段，task 里自己读
+# molcfg.yaml:
+#   profiles:
+#     dry-run:
+#       skip_heavy_compute: true
+if ctx.config.get("skip_heavy_compute"):
+    return mock_result()
+
+# 或纯参数变体
+if ctx.config["epochs"] < 5:
+    ...
+
+# 也可以按 profile 名分支（不推荐，耦合命名）
+if ctx.config.name == "dry_run":
+    ...
+```
+
+### 3.4 RunMetadata
+
+```python
+class RunMetadata(BaseModel):
+    id: str
+    status: str = "pending"        # pending/running/succeeded/failed/cancelled
+    profile: str | None = None     # 新增：activated profile name, e.g. "dry-run"
+    config_hash: str | None = None # 新增：content-hash of resolved ProfileConfig
+    # 删除: dry_run: bool
+    ...
+```
+
+### 3.5 RunStatus
+
+```python
+class RunStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+    # 删除: DRY_RUN
+```
+
+Profile 与状态正交。Profile 为 `dry-run` 的 run 跑完了照样是 `SUCCEEDED`。
+
+### 3.6 CLI
+
+```
+molexp run script.py [--config PATH] [--profile NAME] [--local|--slurm|...]
+                     [--resume]
+
+--config PATH    默认 ./molcfg.yaml，找不到则 profile 必须为空或报错
+--profile NAME   激活的 profile 名，默认无（= 用 defaults）
+--resume         重跑 profile 匹配、状态非 succeeded 的 run
+```
+
+**删除**: `--dry-run` flag。用 `--profile dry-run` 代替。
+
+### 3.7 UI
+
+- Run 列表：紧邻 status 的位置显示 `[{profile}]` 徽章（若 profile 非空）
+- 颜色映射可配置，但默认：`dry-run`=yellow, `smoke`=cyan, 其它=dim
+- 不再有 "dry_run" 状态徽章
+
+### 3.8 Resume 语义
+
+新规则：`--resume --profile X` 找所有 `profile == X and status != "succeeded"`
+的 run，重新执行。旧的"只 resume dry-run 状态"逻辑泛化为"resume
+任意 profile"。
+
+## 4. Roadmap
+
+**Phase 1** (本次): 核心替换
+- 引入 `molexp.config` 模块（MolCfg/ProfileConfig/加载器）
+- 替换 ExecutionConfig → ProfileConfig
+- 删除 RunStatus.DRY_RUN、RunMetadata.dry_run
+- CLI 改用 --config/--profile
+- Server / schemas 同步
+- 测试全绿
+
+**Phase 2** (后续 PR): UI
+- 新 profile 徽章组件
+- 徽章颜色配置项
+
+**Phase 3** (后续): 文档
+- quick-start 改写
+- README 更新
+
+## 5. Todo List
+
+见 TaskList；核心路径：
+
+1. 建 `src/molexp/config/` 模块：models + loader + resolver
+2. 改 `workspace/models.py`：ExecutionConfig → ProfileConfig，RunMetadata 字段
+3. 改 `workspace/run.py`：删 DRY_RUN 枚举，ctx 暴露 config 而非 dry_run
+4. 改 `workflow/context.py`：替换 dry_run property → config property
+5. 改 `workflow/_pydantic_graph/state.py + node.py + runtime.py + compiler.py`
+6. 改 `workflow/spec.py + runtime.py`：execute() 接受 profile
+7. 改 `cli/__init__.py`：--config/--profile，删 --dry-run 及其分支
+8. 改 `server/routes/run.py`：状态列表更新
+9. 改 `monitor.py`：徽章逻辑
+10. 迁移现有测试（tests/）
+11. 添加新测试：config 加载、profile 解析、继承
+12. 运行完整 pytest 确认绿
diff --git a/docs/spec/unified-pydantic-graph-dispatch.md b/docs/spec/unified-pydantic-graph-dispatch.md
new file mode 100644
index 00000000..f29b5048
--- /dev/null
+++ b/docs/spec/unified-pydantic-graph-dispatch.md
@@ -0,0 +1,423 @@
+# 统一 pydantic-graph 调度: Sweep 与 Backend 并入外层图
+
+**状态**: Draft · **作者**: @RoyKid · **日期**: 2026-04-17
+
+## 实施状态
+
+| Phase | 状态 | 落地日期 | 备注 |
+|-------|------|---------|------|
+| 1 — Sweep pydantic-graph 化(仅 `--local` + `-j N`) | ✅ 已完成 | 2026-04-17 | 新增 `molexp.sweep` 包、`-j/--jobs` CLI flag、profile `jobs:` 字段约定;`molexp run --local -j N` 启用 sweep 级并发 |
+| 2 — Backend 统一入口(`--backend`, `--block`) | ⏳ 待开始 | — | 需要先让 `molq.JobHandle` 支持 `wait_async` 或包 `asyncio.to_thread` |
+| 3 — Per-node backend(`@wf.task(backend=..., resources=...)`) | ⏳ 待开始 | — | 依赖 Phase 2 |
+| 4 — molq 原生 async API | ⏳ 独立推进 | — | 在 molq 仓完成 `monitor.py` async 化 |
+
+**Phase 1 变更清单**:
+- `src/molexp/sweep/__init__.py`、`src/molexp/sweep/graph.py`(`SweepReplica`, `SweepState`, `SweepRoot`, `run_sweep`)
+- `src/molexp/cli/run_cmd.py` 拆分 `_execute_sweep`:`_discover_runs` + `_dispatch_local`(pydantic-graph)+ `_dispatch_cluster`(保留旧路径);新增 `-j/--jobs` CLI 参数和 `_resolve_jobs` 辅助
+- `tests/test_sweep/test_graph.py`(9 个单测)+ `tests/test_cli_run_jobs.py`(6 个 E2E 测试)
+
+**当前 profile 约定**:`jobs: <int>` 是用户数据(schemaless,见 §2 及 `docs/spec/molcfg-profiles.md`)。CLI `-j` 优先级高于 profile,profile 值 > 1 触发并行,默认 1(向后兼容)。
+
+## 1. 动机
+
+当前 `molexp run` 存在两层完全独立的调度:
+
+| 层次 | 位置 | 并行模型 | 快照/恢复 |
+|------|------|----------|-----------|
+| **Sweep**(跨 experiment × replica) | `cli/run_cmd.py:_execute_sweep` 的 `for` 循环 | `--local` 强串行;`--slurm` 交给外部调度器 | 仅靠 run-id 去 store 里匹配,无 in-process 状态 |
+| **Workflow**(task DAG) | `workflow/_pydantic_graph/` | 同 level 内 `asyncio.gather` | 有 pydantic-graph snapshot |
+
+这带来四个问题:
+
+1. **`--local` 不能并行**: 明明多个 experiment 互相无依赖,`for` 循环 + 阻塞
+   `asyncio.run()` 强制串行(见 `cli/run_cmd.py:206-209, 467-472`)。
+2. **两套 dispatch 路径**: `_local_handler` 和 `SubmitHandler` 是两套代码,同样的
+   "把一个 run 跑起来"有两个完全不同的分支(`run_cmd.py:452-482` vs
+   `run_cmd.py:484-543`)。
+3. **`--slurm` fire-and-forget 不可观测**: 父进程提交完立即退出,sweep 层没有
+   graph 状态,`molexp watch` 必须单独实现数据库轮询逻辑来反推进度。
+4. **无法 per-node 选后端**: 想让 `prepare_data` 跑在本地、`train_model` 上 GPU
+   集群是常见需求,当前架构不支持——`--slurm` 是整个脚本层级的开关。
+
+**目标**: 把"sweep"也建模成一个 pydantic-graph,让 local / molq / 未来的其他
+backend 都成为**某个 node 内部的 await 操作**,而不是顶层的两种 dispatch。
+
+**非目标**:
+- 不改 molq 内部模型(job store / reconciler / monitor 保持不变)。
+- 不改内层 workflow 的 task 协议(`@wf.task` 语义保持)。
+- 不为本地引入子进程池——local 就是 in-process async 并发。GPU 训练的真并行
+  交给 molq 的 local scheduler 或远程 scheduler。
+
+## 2. 设计原则
+
+1. **pydantic-graph 是唯一编排器**: 所有执行语义——串/并、本地/远程、
+   snapshot/resume——都通过 graph 节点 + async body 表达。不存在 graph 之外的
+   调度循环。
+2. **Backend 是 node body 的实现细节**: `@wf.task` 不关心自己跑在哪;跑哪儿由
+   decorator 参数、profile 配置和 CLI 覆盖在运行时决定。
+3. **默认零改动**: 现有脚本(如 `examples/train_allegro_qm9.py`)**不需要任何
+   源码修改**即可在新架构下运行。所有新能力通过 profile / decorator 参数开启。
+4. **Block 语义由用户控制**: `block=True` 节点 `await` 到作业终止,父进程必须
+   存活;`block=False` 节点返回 `job_id` 立刻完成,后续状态交给 molq store。
+5. **Account/resources 三级继承**: profile 兜底 → decorator 默认 → CLI/ctx
+   覆盖。用户只在"特殊"节点显式覆盖。
+6. **旧 CLI flag 作为别名保留**: `--local` / `--slurm` / `--pbs` / `--lsf` 映射
+   到新的 `--backend` + profile,不做 deprecation 期强制迁移。
+
+## 3. 核心架构
+
+### 3.1 两层 Graph
+
+```
+SweepGraph(外层)
+  节点: 每个 (experiment × replica)
+  边:   无(所有 replica 互相独立)
+  并发: asyncio.Semaphore(jobs) 节流同 level 并发
+  Body: await _run_one_replica(run, exp, profile_cfg)
+
+       ├─ backend=local:
+       │    inner = exp.workflow.execute(run_context=ctx)
+       │    await inner                              # 进程内直跑
+       │
+       └─ backend=slurm/pbs/lsf:
+            handle = submitor.submit(
+                argv=[python, -m, worker, script, run_dir, --task <name>?],
+                resources=..., execution=...)
+            if block:
+                record = await handle.wait_async()   # 父进程守候
+                return {"state": record.state.name, "job_id": handle.job_id}
+            else:
+                return {"job_id": handle.job_id}     # fire-and-forget
+
+WorkflowGraph(内层,保持现状)
+  节点: @wf.task
+  边:   depends_on
+  Body: 保持现有 async def 协议
+```
+
+### 3.2 Per-node Backend(进阶路径)
+
+默认"一个 experiment 一个远程 job"(整个内层 workflow 打包提交)。当用户希望
+混合执行(e.g. `prepare_data` 本地、`train_model` 上 GPU),在内层某个 `@wf.task`
+上标注 `backend=`,框架把这个 task 作为独立 molq job 提交:
+
+```python
+@wf.task(depends_on=["prepare_data"],
+         backend="slurm",
+         resources=TaskResources(gpus=1, time="12h", mem="64G"))
+async def train_model(ctx): ...
+```
+
+远端用同一份 `worker.py` 入口,加 `--task <name>` 参数来选择"只跑一个 node"
+而不是整个 workflow(见 §5.3)。
+
+### 3.3 并发度控制
+
+```
+molexp run script.py -j 4                    # sweep 级 4 并发
+molexp run script.py -j 4 --backend slurm    # 4 路同时提交 slurm + await
+molexp run script.py                         # -j 默认 1(= 当前行为)
+```
+
+`-j N` 的实现就是外层 `SweepGraph` 节点执行器里的
+`asyncio.Semaphore(N)`——直接复用 `workflow/_pydantic_graph/node.py:88-124` 的
+`_execute_parallel` 模式。
+
+## 4. 用户 API
+
+### 4.1 CLI
+
+```bash
+# 推荐新写法
+molexp run script.py --backend {local,slurm,pbs,lsf,...} \
+                     [-j N] [--block/--no-block] \
+                     [-c molcfg.yaml] [--profile NAME]
+
+# 旧 flag 保留为别名(zero-cost 迁移)
+molexp run script.py --local        # ≡ --backend local -j 1
+molexp run script.py --slurm        # ≡ --backend slurm --no-block (保持 fire-and-forget 行为)
+```
+
+**默认值**:
+- `--backend`: `local`
+- `-j`: `1`(向后兼容,显式设 `-j auto` = CPU 核数)
+- `--block`: `local` 下无意义(本就是 await);`slurm` 下默认 `--no-block`
+  匹配旧行为。未来版本可切换成 `--block` 默认,按社区反馈。
+
+### 4.2 Profile(molcfg.yaml)
+
+```yaml
+default: &base
+  smoke: false
+
+profiles:
+  local_quick:
+    <<: *base
+    backend: local
+    jobs: 4                        # -j 等价写法
+
+  prod_gpu:
+    <<: *base
+    backend: slurm
+    block: true                    # 父进程守候
+    jobs: 8                        # 同时提交/守候 8 个 job
+    slurm:
+      cluster: "perlmutter"
+      account: "mycompchem"
+      qos: "regular"
+      partition: "gpu"
+
+  mixed:
+    <<: *base
+    backend: local                 # 外层 sweep 本地并发
+    jobs: 16
+    per_node_backend: true         # 允许内层 task 上的 backend= 生效
+    slurm:                         # 内层 task 用到时继承
+      cluster: "perlmutter"
+      account: "mycompchem"
+```
+
+### 4.3 Decorator(脚本内)
+
+```python
+from molexp import TaskResources
+
+@wf.task(
+    depends_on=["prepare_data"],
+    backend="slurm",                                        # per-node 覆盖
+    resources=TaskResources(gpus=1, time="12h", mem="64G"),
+)
+async def train_model(ctx): ...
+```
+
+**决策链**: CLI 覆盖 > profile > decorator > 框架默认。`account` / `cluster` /
+`qos` 这类机构级字段**永远**从 profile 取,不进脚本(便于跨机器复用)。
+
+### 4.4 TaskContext 扩展
+
+```python
+@wf.task
+async def some_task(ctx: TaskContext):
+    # 新增: 手动提交(高阶用户)
+    handle = await ctx.molq.submit(
+        argv=[...], resources=..., execution=...)
+    record = await handle.wait_async()
+    ...
+```
+
+`ctx.molq` 在非 molq 后端下可用(fallback 到 `local` scheduler),使用户代码不
+依赖 CLI 选的 backend。
+
+## 5. 内部实现
+
+### 5.1 SweepGraph
+
+新文件 `molexp/sweep/graph.py`:
+
+```python
+from pydantic_graph import BaseNode, End, GraphRunContext
+import asyncio
+
+@dataclass
+class ReplicaNode(BaseNode[SweepState, SweepDeps, SweepResult]):
+    mol_run: Run
+    experiment: Experiment
+
+    async def run(self, ctx) -> "ReplicaNode | End[SweepResult]":
+        async with ctx.deps.semaphore:             # -j N 节流
+            backend = _resolve_backend(
+                ctx.deps.profile_cfg,
+                self.experiment)
+            if backend == "local":
+                await self.experiment.workflow.execute(
+                    run=self.mol_run,
+                    profile_config=ctx.deps.profile_cfg)
+            else:
+                await _submit_and_maybe_wait(
+                    backend=backend,
+                    mol_run=self.mol_run,
+                    profile_cfg=ctx.deps.profile_cfg)
+        # ReplicaNode 是叶子,直接 End
+        return End(...)
+
+def build_sweep_graph(workspaces, profile_cfg, jobs: int) -> Graph:
+    # 汇总所有 (project, experiment, replica),构建单级并行图
+    ...
+```
+
+### 5.2 `_execute_sweep` 重构
+
+`cli/run_cmd.py` 现有的 94 行 `_execute_sweep` 大幅简化:
+
+```python
+async def _execute_sweep_async(script, profile_cfg, resume, workspace, jobs):
+    workspaces = load_workspaces(script)
+    runs = _discover_runs(workspaces, profile_cfg, resume)   # 保留当前 resume 逻辑
+    graph = build_sweep_graph(runs, profile_cfg, jobs=jobs)
+    await graph.run(...)
+
+def _execute_sweep(...):
+    asyncio.run(_execute_sweep_async(...))
+```
+
+`_local_handler` 和 `SubmitHandler` 被删除(其逻辑迁移进 `ReplicaNode.run`)。
+
+### 5.3 `worker.py` 扩展
+
+`molexp/plugins/submit_molq/worker.py` 增加 `--task <name>` 选项:
+
+```python
+# 旧: python -m worker <script> <run_dir>
+#     (跑整个 workflow)
+# 新: python -m worker <script> <run_dir> [--task <node_name>]
+#     不带 --task 保持旧行为(整个 workflow)
+#     带 --task 只执行指定 node(per-node backend 用)
+```
+
+### 5.4 molq async 接口
+
+molq 的 `JobHandle.wait()` 是 blocking 轮询(`monitor.py:40-96`)。过渡期:
+
+```python
+# molexp 侧临时方案
+async def wait_async(handle, *, timeout=None):
+    return await asyncio.to_thread(handle.wait, timeout=timeout)
+```
+
+长期方案:molq 本身加 `JobHandle.wait_async()`,把 `monitor.py` 的
+`threading.Event.wait(interval)` 轮询循环改写成 `asyncio.sleep(interval)`。
+独立 PR,不阻塞本 spec。
+
+### 5.5 Snapshot / Resume
+
+pydantic-graph 的 snapshot 机制天然支持 `SweepGraph`。新增能力:
+
+- **父进程崩溃恢复**: 快照包含每个 replica 的 `job_id`(如已提交)。重启后
+  对还在 running 的作业,节点从 `handle.wait_async()` 重新 await——molq store
+  按 `job_id` 幂等查询状态。
+- **`--resume` 语义**: 复用现有 `run_cmd.py:179-198` 的 run-id 匹配逻辑,只是
+  进入点从 `for` 循环变成 `SweepGraph.resume(snapshot)`。
+
+## 6. 迁移路径
+
+### Phase 1: Sweep 层 pydantic-graph 化(仅 `--local`)
+
+- 新增 `SweepGraph`,仅支持 `backend=local`
+- `--local` 下的 `-j N` 生效
+- 其他 backend 暂时继续走旧 `SubmitHandler`(保留两套代码)
+- **用户可见变化**: `molexp run --local -j 4` 开始工作
+- **风险**: 低。纯新增代码,老路径不动。
+
+### Phase 2: Backend 统一入口
+
+- 删除 `_local_handler` 和 `SubmitHandler`,所有 backend 走 `SweepGraph`
+- `ReplicaNode.run` 根据 `backend` 分支(local 直跑 / molq 提交)
+- 加入 `--block/--no-block` 支持
+- `worker.py` 行为不变
+- **用户可见变化**: `--backend slurm --block` 出现;`--slurm` 仍可用,语义等价
+- **风险**: 中。slurm 路径重写,需要回归集群侧真机测试。
+
+### Phase 3: Per-node backend
+
+- `@wf.task(backend=..., resources=...)` 生效
+- `worker.py` 加 `--task` 选项
+- profile 加 `per_node_backend: true` 开关(默认 false,避免误启用)
+- **用户可见变化**: 进阶用户可以混合执行
+- **风险**: 中。需要 node 输入输出落盘约定的最佳实践文档。
+
+### Phase 4: molq async API
+
+- molq 原生 `wait_async()` 上线,molexp 去掉 `asyncio.to_thread` wrapper
+- 独立推进,和 Phase 1/2/3 解耦
+
+### 时间估算
+
+| Phase | 预估工作量 | 依赖 |
+|-------|-----------|------|
+| 1 | 2-3 天 | 无 |
+| 2 | 3-4 天 | Phase 1 |
+| 3 | 3-5 天 | Phase 2 |
+| 4 | 2-3 天(molq 侧) | 独立 |
+
+## 7. 对现有脚本的影响
+
+以 `molnex/examples/train_allegro_qm9.py` 为参照:
+
+| 代码段 | Phase 1 | Phase 2 | Phase 3 |
+|--------|---------|---------|---------|
+| `experiments = [...]` (73-85) | 不变 | 不变 | 不变 |
+| `@wf.task prepare_data` (174-232) | 不变 | 不变 | 可选:加 `backend="local"` 显式标注(非必需) |
+| `@wf.task train_model` (235-416) | 不变 | 不变 | 可选:`backend="slurm", resources=...` 启用 per-node 提交 |
+| `me.entry(ws)` (428) | 不变 | 不变 | 不变 |
+| `molcfg.yaml` | 可新增 `jobs:` | 可新增 `backend: / block:` | 可新增 `per_node_backend: true` |
+
+**结论**: 用户脚本代码永远保持现状。所有新能力开关在 profile 或 decorator。
+
+## 8. 兼容性
+
+### 8.1 CLI 别名表
+
+| 旧 flag | 新等价写法 |
+|---------|-----------|
+| `--local` | `--backend local -j 1` |
+| `--local --bg` | `--backend local -j 1` + `nohup` 包装(`--bg` 功能保留) |
+| `--slurm` | `--backend slurm --no-block` |
+| `--slurm --block` | `--backend slurm --block`(语义同旧) |
+| `--scheduler local` | `--backend local`(如果是 molq 的 local scheduler,仍然是 `--backend slurm` 但用 molq local cluster) |
+
+### 8.2 破坏性变更
+
+**无**。所有现有调用方式保持。Phase 2 后 `SubmitHandler` 的 class API 消失,但
+这是内部实现,不在公共 API 契约内。
+
+### 8.3 配置文件兼容
+
+- 旧 profile 不含 `backend:` / `jobs:` 字段时,默认 `backend: local, jobs: 1`
+  = 旧行为。
+- 新字段位置参见 §4.2。
+
+## 9. 测试策略
+
+### 9.1 新增单元测试
+
+- `tests/test_sweep/test_graph.py`: `SweepGraph` 基本执行、并发度、snapshot
+- `tests/test_sweep/test_backend_resolution.py`: CLI > profile > decorator 优先级
+- `tests/test_sweep/test_resume.py`: 父进程重启从快照恢复 job
+
+### 9.2 集成测试
+
+- `molexp run --backend local -j 4` 实际并发度(通过 task 内的 sleep 计时)
+- `molexp run --backend slurm --block` 在 molq `testing` scheduler(内存模拟)上
+  端到端跑通
+- 混合 backend:一个 task `local` + 一个 task `slurm`,检查输入输出交接
+
+### 9.3 回归测试
+
+- 现有 `tests/test_cli/test_run_cmd.py` 全部保持 pass
+- `examples/train_allegro_qm9.py` 在 Phase 2 后用 `--backend local --smoke` 跑完
+
+## 10. 开放问题
+
+1. **`--no-block` 下 `molexp run` 的 exit code**: 作业已提交但未完成,返回 0
+   表示"提交成功"还是非 0 表示"未验证完成"?倾向返回 0 + stdout 明确告知需要
+   `molexp watch`。
+2. **`-j auto` 含义**: CPU 核数?GPU 数量?对 local 合理,对 slurm 作为"并发守候
+   上限"可能过大。建议 `auto` 仅 local 生效,slurm 要求显式 `-j N`。
+3. **Per-node snapshot 粒度**: 一个 replica 内多个 node 各自提交 job,某个
+   node 失败后 resume 是重跑失败 node 还是整个 replica?pydantic-graph 的默认
+   是 per-node,沿用即可,但需要文档强调。
+4. **TaskResources 的 schema**: 直接复用 molq 的 `JobResources`(`gpu_count`
+   / `memory` / `time_limit`),还是包一个 molexp 自己的类型?倾向复用,减少
+   转换层。
+5. **ctx.molq 在 local backend 下的语义**: 应该 fallback 到 molq 的 `local`
+   scheduler,还是 raise?倾向前者——用户代码保持 backend-agnostic。
+
+## 11. 参考
+
+- `cli/run_cmd.py:206-209, 452-543` 当前 sweep 双路径实现
+- `workflow/_pydantic_graph/node.py:88-124` 内层 level 并发模板
+- `plugins/submit_molq/submit.py:52-115` 当前 SubmitHandler
+- `plugins/submit_molq/worker.py:18-56` 现有 worker 入口
+- `molq/submitor.py:197-251, 1120-1154` JobHandle 现状
+- `molq/monitor.py:40-96` 阻塞轮询,待 async 化
+- 关联 spec: `docs/spec/molcfg-profiles.md`(profile 机制)
diff --git a/package.json b/package.json
index 308f7bd4..84083865 100644
--- a/package.json
+++ b/package.json
@@ -1,4 +1,20 @@
 {
+  "name": "molexp",
+  "version": "0.2.0",
+  "description": "Workflow and agent platform for research experiment management",
+  "private": true,
+  "workspaces": ["ui"],
+  "scripts": {
+    "dev": "npm run dev -w molexp-ui",
+    "dev:mock": "npm run dev:mock -w molexp-ui",
+    "build": "npm run build -w molexp-ui",
+    "build:ui": "npm run build -w molexp-ui && rm -rf src/molexp/_webapp && mkdir -p src/molexp/_webapp && cp -r ui/dist/. src/molexp/_webapp/",
+    "build:python": "npm run build:ui",
+    "typecheck": "npm run typecheck -w molexp-ui",
+    "test:ui": "npm run test -w molexp-ui",
+    "lint": "npm run lint -w molexp-ui",
+    "generate:api": "npm run generate:api -w molexp-ui"
+  },
   "devDependencies": {
     "shadcn": "^3.6.3"
   }
diff --git a/pyproject.toml b/pyproject.toml
index 990551d3..16268962 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,25 +1,62 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
 [project]
 name = "molexp"
-version = "0.1.0"
-description = "Minimal task graph framework with compiler, engine, and DSL"
-authors = [{name = "OpenAI Agent"}]
+version = "0.2.0"
+description = "Workflow and agent platform for research experiment management"
+authors = [{name = "molcrafts"}]
+license = {text = "BSD-3-Clause"}
 requires-python = ">=3.12"
+
 dependencies = [
-    "pydantic>=2.5",
+    "pydantic>=2.10",
+    "pydantic-graph>=1.0",
     "pyyaml>=6.0",
     "typer>=0.9.0",
-    "rich>=13.0.0",
-    "psutil>=5.9.0",
+    "rich>=14.3.4",
     "fastapi>=0.100.0",
     "uvicorn>=0.23.0",
+    "molcrafts-mollog>=1.0.0",
+    "molcrafts-molcfg>=1.2.0",
+]
+
+[project.optional-dependencies]
+agent = ["pydantic-ai>=1.0"]
+remote = []                          # molq when published
+all = ["molexp[agent,remote]"]
+dev = [
+    "molexp[all]",
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+    "httpx>=0.24",
+    "psutil>=5.9.0",
 ]
 
 [project.scripts]
 molexp = "molexp.cli:app"
 
-[project.entry-points."molexp.nodes"]
-builtin = "molexp.workflow.nodes.register:register_builtin_nodes"
+[tool.ruff]
+line-length = 100
+target-version = "py312"
 
-[build-system]
-requires = ["setuptools", "wheel"]
-build-backend = "setuptools.build_meta"
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+ignore = ["E501"]
+
+[tool.hatch.build]
+# Ship the built frontend bundle inside the wheel — populated by
+# `npm run build:ui` before `python -m build --wheel`.
+artifacts = [
+    "src/molexp/_webapp/**",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/molexp"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+    "/README.md",
+]
diff --git a/src/molexp/__init__.py b/src/molexp/__init__.py
index 1fd074f2..d2c972c4 100644
--- a/src/molexp/__init__.py
+++ b/src/molexp/__init__.py
@@ -1,16 +1,47 @@
-"""molexp: Molecular experiment workflow framework.
+"""molexp: Workflow and agent platform for research experiment management.
 
-Shortcut imports for common user-facing APIs:
-- molexp.workflow: Workflow system (Task, WorkflowCompiler, WorkflowEngine, etc.)
-- molexp.workspace: Workspace management (Workspace, Project, Experiment, Run, Asset, etc.)
+Core packages:
+    - ``molexp.workspace``: File-system-backed experiment management
+    - ``molexp.workflow``: DAG-based workflow definition and execution
+    - ``molexp.plugins``: Optional capabilities (remote HPC, AI agent, ...)
 """
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"
 
-from . import workflow
-from . import workspace
+from molexp.entry import entry
+
+# User-facing hierarchy (all from workspace — single source of truth)
+from molexp.workspace.experiment import Experiment
+from molexp.workspace.param import GridSpace, ParamSpace, UniformSpace
+from molexp.workspace.project import Project
+from molexp.workspace.run import Run, RunContext
+from molexp.workspace.workspace import Workspace
 
 __all__ = [
-    "workflow",
-    "workspace",
+    "Workspace",
+    "Project",
+    "Experiment",
+    "Run",
+    "RunContext",
+    "GridSpace",
+    "UniformSpace",
+    "ParamSpace",
+    "entry",
 ]
+
+
+# Lazy imports — heavy sub-packages are only loaded on first access.
+def __getattr__(name: str):
+    if name == "workspace":
+        from molexp import workspace as _ws
+
+        return _ws
+    if name == "workflow":
+        from molexp import workflow as _wf
+
+        return _wf
+    if name == "plugins":
+        from molexp import plugins as _pl
+
+        return _pl
+    raise AttributeError(f"module 'molexp' has no attribute {name!r}")
diff --git a/src/molexp/__pycache__/__init__.cpython-312.pyc b/src/molexp/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index f57d80e2..00000000
Binary files a/src/molexp/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/__init__.cpython-313.pyc b/src/molexp/__pycache__/__init__.cpython-313.pyc
deleted file mode 100644
index 90ce3785..00000000
Binary files a/src/molexp/__pycache__/__init__.cpython-313.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/assets.cpython-312.pyc b/src/molexp/__pycache__/assets.cpython-312.pyc
deleted file mode 100644
index ebf483ac..00000000
Binary files a/src/molexp/__pycache__/assets.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/cli.cpython-312.pyc b/src/molexp/__pycache__/cli.cpython-312.pyc
deleted file mode 100644
index 68350151..00000000
Binary files a/src/molexp/__pycache__/cli.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/compiler.cpython-312.pyc b/src/molexp/__pycache__/compiler.cpython-312.pyc
deleted file mode 100644
index 70493bd8..00000000
Binary files a/src/molexp/__pycache__/compiler.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/context.cpython-312.pyc b/src/molexp/__pycache__/context.cpython-312.pyc
deleted file mode 100644
index 3a1d0d05..00000000
Binary files a/src/molexp/__pycache__/context.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/dsl.cpython-312.pyc b/src/molexp/__pycache__/dsl.cpython-312.pyc
deleted file mode 100644
index 501f2568..00000000
Binary files a/src/molexp/__pycache__/dsl.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/engine.cpython-312.pyc b/src/molexp/__pycache__/engine.cpython-312.pyc
deleted file mode 100644
index 1587ca1c..00000000
Binary files a/src/molexp/__pycache__/engine.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/engine.cpython-313.pyc b/src/molexp/__pycache__/engine.cpython-313.pyc
deleted file mode 100644
index 1fc2bf07..00000000
Binary files a/src/molexp/__pycache__/engine.cpython-313.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/id_utils.cpython-312.pyc b/src/molexp/__pycache__/id_utils.cpython-312.pyc
deleted file mode 100644
index bc75a76b..00000000
Binary files a/src/molexp/__pycache__/id_utils.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/models.cpython-312.pyc b/src/molexp/__pycache__/models.cpython-312.pyc
deleted file mode 100644
index 9663a536..00000000
Binary files a/src/molexp/__pycache__/models.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/server_manager.cpython-312.pyc b/src/molexp/__pycache__/server_manager.cpython-312.pyc
deleted file mode 100644
index eb90fba0..00000000
Binary files a/src/molexp/__pycache__/server_manager.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/task_base.cpython-312.pyc b/src/molexp/__pycache__/task_base.cpython-312.pyc
deleted file mode 100644
index 3a7f7a10..00000000
Binary files a/src/molexp/__pycache__/task_base.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/task_graph.cpython-312.pyc b/src/molexp/__pycache__/task_graph.cpython-312.pyc
deleted file mode 100644
index 8dedf306..00000000
Binary files a/src/molexp/__pycache__/task_graph.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/task_graph_compiler.cpython-312.pyc b/src/molexp/__pycache__/task_graph_compiler.cpython-312.pyc
deleted file mode 100644
index 8db40bfa..00000000
Binary files a/src/molexp/__pycache__/task_graph_compiler.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/workflow_inspector.cpython-312.pyc b/src/molexp/__pycache__/workflow_inspector.cpython-312.pyc
deleted file mode 100644
index da331a9f..00000000
Binary files a/src/molexp/__pycache__/workflow_inspector.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/workflow_registry.cpython-312.pyc b/src/molexp/__pycache__/workflow_registry.cpython-312.pyc
deleted file mode 100644
index 04fc76a1..00000000
Binary files a/src/molexp/__pycache__/workflow_registry.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/workspace.cpython-312.pyc b/src/molexp/__pycache__/workspace.cpython-312.pyc
deleted file mode 100644
index fbb57596..00000000
Binary files a/src/molexp/__pycache__/workspace.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/__pycache__/workspace_validator.cpython-312.pyc b/src/molexp/__pycache__/workspace_validator.cpython-312.pyc
deleted file mode 100644
index 9a7478b3..00000000
Binary files a/src/molexp/__pycache__/workspace_validator.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/_webapp/.gitkeep b/src/molexp/_webapp/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/src/molexp/cli/__init__.py b/src/molexp/cli/__init__.py
index 88676f6d..453891e3 100644
--- a/src/molexp/cli/__init__.py
+++ b/src/molexp/cli/__init__.py
@@ -1,22 +1,12 @@
-"""Command-line interface for molexp."""
+"""Command-line interface for molexp.
 
-from __future__ import annotations
+The ``app`` Typer instance is created here; individual command modules
+are imported below for their registration side effects.
+"""
 
-import os
-import signal
-import subprocess
-import sys
-import time
-from pathlib import Path
-from typing import Annotated, Optional
+from __future__ import annotations
 
 import typer
-import uvicorn
-from rich import print as rprint
-from rich.console import Console
-from molexp.workspace import Workspace
-from molexp.server.app import create_app
-
 
 app = typer.Typer(
     name="molexp",
@@ -24,708 +14,17 @@
     no_args_is_help=True,
 )
 
-console = Console()
-
-
-@app.command()
-def serve(
-    workdir: Annotated[
-        Path,
-        typer.Option(
-            "--workdir",
-            "-w",
-            help="Workspace directory path",
-            exists=True,
-            file_okay=False,
-            dir_okay=True,
-            writable=True,
-            resolve_path=True,
-        ),
-    ] = Path.cwd(),
-    port: Annotated[
-        int,
-        typer.Option("--port", "-p", help="Server port"),
-    ] = 8000,
-    host: Annotated[
-        str,
-        typer.Option("--host", "-h", help="Server host"),
-    ] = "localhost",
-    dev: Annotated[
-        bool,
-        typer.Option("--dev", help="Development mode (API only, reload enabled)"),
-    ] = False,
-) -> None:
-    """Start the MolExp Backend Server.
-    
-    Arguments:
-        workdir: Workspace directory.
-        dev: If set, enables hot-reload and disables static file serving (API Only).
-             The frontend must be run separately (e.g., 'npm run dev').
-    """
-    # 1. Switch to workspace directory
-    # This allows the backend to find workspace files relative to CWD.
-    os.chdir(workdir)
-    
-    rprint(f"[bold]Serving Workspace:[/bold] {workdir}")
-    rprint(f"[cyan]→[/cyan] API Server at http://{host}:{port}")
-    
-    if dev:
-        rprint("[yellow]Development Mode:[/yellow] Reload active. Serving API only.")
-        # Dev Mode: Use import string to enable reload.
-        # Relies on 'app = create_app()' at module level in app.py for default config.
-        uvicorn.run(
-            "molexp.server.app:app", 
-            host=host, 
-            port=port, 
-            reload=True,
-            log_level="info"
-        )
-    else:
-        # Production Mode: Serve Static Files
-        # Locate UI distribution relative to the installed package location.
-        # def load_static_dir():
-        raise NotImplementedError("Static file serving is not implemented yet.")
-
-# ============ Workspace Commands ============
-
-
-@app.command()
-def init(
-    path: Annotated[
-        Optional[Path],
-        typer.Argument(help="Workspace path (default: current directory)"),
-    ] = None,
-) -> None:
-    """Initialize a new workspace."""
-    workspace_path = path or Path.cwd()
-    workspace = Workspace.from_path(workspace_path)
-
-    rprint(f"[green]✓[/green] Initialized workspace at: {workspace.root}")
-    rprint(f"  - Projects directory: {workspace.root / 'projects'}")
-    rprint(f"  - Assets directory: {workspace.root / 'assets'}")
-
-
-@app.command()
-def info(
-    path: Annotated[
-        Optional[Path],
-        typer.Option("--path", "-p", help="Workspace path"),
-    ] = None,
-) -> None:
-    """Show workspace information."""
-    workspace = _get_workspace(path)
-
-    projects = workspace.list_projects()
-    assets = workspace.list_assets()
-
-    # Gather detailed statistics
-    total_experiments = 0
-    total_runs = 0
-    run_status_counts = {
-        "pending": 0,
-        "running": 0,
-        "succeeded": 0,
-        "failed": 0,
-        "cancelled": 0,
-    }
-
-    for project in projects:
-        experiments = workspace.list_experiments(project.id)
-        total_experiments += len(experiments)
-
-        for experiment in experiments:
-            runs = workspace.list_runs(project.id, experiment.id)
-            total_runs += len(runs)
-
-            for run in runs:
-                status = run.status.value.lower()
-                if status in run_status_counts:
-                    run_status_counts[status] += 1
-
-    # Calculate total asset size
-    total_asset_size = sum(asset.size_bytes for asset in assets)
-    total_asset_size_mb = total_asset_size / (1024 * 1024)
-
-    rprint(f"[bold]Workspace:[/bold] {workspace.root}")
-    rprint(f"\n[bold]Statistics:[/bold]")
-    rprint(f"  Projects: {len(projects)}")
-    rprint(f"  Experiments: {total_experiments}")
-    rprint(f"  Runs: {total_runs}")
-    rprint(f"  Assets: {len(assets)} ({total_asset_size_mb:.2f} MB)")
-
-    if total_runs > 0:
-        rprint(f"\n[bold]Run Status:[/bold]")
-        for status, count in run_status_counts.items():
-            if count > 0:
-                color = {
-                    "succeeded": "green",
-                    "failed": "red",
-                    "running": "yellow",
-                    "pending": "blue",
-                    "cancelled": "gray",
-                }.get(status, "white")
-                rprint(f"  [{color}]{status.capitalize()}[/{color}]: {count}")
-
-
-@app.command()
-def check(
-    path: Annotated[
-        Optional[Path],
-        typer.Option("--path", "-p", help="Workspace path"),
-    ] = None,
-    fix: Annotated[
-        bool,
-        typer.Option("--fix", help="Attempt to fix issues automatically"),
-    ] = False,
-    verbose: Annotated[
-        bool,
-        typer.Option("--verbose", "-v", help="Show detailed validation results"),
-    ] = False,
-) -> None:
-    """Validate workspace integrity."""
-    workspace = _get_workspace(path)
-    validator = WorkspaceValidator(workspace)
-
-    rprint("[bold]Validating workspace...[/bold]\n")
-
-    report = validator.validate(verbose=verbose)
-
-    # Show statistics
-    rprint(f"[bold]Statistics:[/bold]")
-    rprint(f"  Projects: {report.total_projects}")
-    rprint(f"  Experiments: {report.total_experiments}")
-    rprint(f"  Runs: {report.total_runs}")
-    rprint(f"  Assets: {report.total_assets}")
-    if report.orphaned_assets > 0:
-        rprint(f"  Orphaned Assets: [yellow]{report.orphaned_assets}[/yellow]")
-
-    # Show issues
-    if report.issues:
-        rprint(f"\n[bold]Issues Found:[/bold]")
-
-        for issue in report.issues:
-            color = {"error": "red", "warning": "yellow", "info": "blue"}.get(
-                issue.severity, "white"
-            )
-            icon = {"error": "✗", "warning": "⚠", "info": "ℹ"}.get(issue.severity, "•")
-
-            rprint(f"  [{color}]{icon}[/{color}] {issue.message}")
-            if verbose and issue.path:
-                rprint(f"      Path: {issue.path}")
-
-        # Attempt fixes if requested
-        if fix:
-            rprint(f"\n[bold]Attempting to fix issues...[/bold]")
-            unfixed = validator.fix_issues(report.issues)
-            fixed_count = len(report.issues) - len(unfixed)
-
-            if fixed_count > 0:
-                rprint(f"  [green]✓[/green] Fixed {fixed_count} issue(s)")
-            if unfixed:
-                rprint(f"  [yellow]⚠[/yellow] Could not fix {len(unfixed)} issue(s)")
-
-    # Show summary
-    rprint(f"\n{report.summary()}")
-
-    if report.has_errors:
-        raise typer.Exit(1)
-
-
-# ============ Workflow Commands ============
-
-workflow_app = typer.Typer(help="Workflow management commands")
-app.add_typer(workflow_app, name="workflow")
-
-
-@workflow_app.command("list")
-def workflow_list(
-    verbose: Annotated[
-        bool,
-        typer.Option("--verbose", "-v", help="Show detailed information"),
-    ] = False,
-) -> None:
-    """List all registered workflows."""
-    registry = get_workflow_registry()
-    inspector = WorkflowInspector(registry)
-
-    workflows = inspector.list_workflows()
-
-    if not workflows:
-        rprint("[yellow]No workflows registered[/yellow]")
-        return
-
-    table = Table(title="Registered Workflows")
-    table.add_column("Workflow ID", style="cyan")
-    table.add_column("Tasks", style="green")
-
-    if verbose:
-        table.add_column("Status")
-
-    for wf in workflows:
-        row = [wf["id"], str(wf["num_tasks"])]
-
-        if verbose:
-            if "error" in wf:
-                row.append(f"[red]{wf['error']}[/red]")
-            else:
-                row.append("[green]OK[/green]")
-
-        table.add_row(*row)
-
-    console.print(table)
-
-
-@workflow_app.command("info")
-def workflow_info(
-    workflow_id: Annotated[str, typer.Argument(help="Workflow ID")],
-) -> None:
-    """Show detailed workflow information."""
-    registry = get_workflow_registry()
-    inspector = WorkflowInspector(registry)
-
-    try:
-        info = inspector.get_workflow_info(workflow_id)
-        tree = inspector.render_tree(workflow_id)
-
-        rprint(f"[bold]Workflow:[/bold] {workflow_id}")
-        rprint(f"  Tasks: {info['num_tasks']}")
-        rprint(f"\n[bold]Task Graph:[/bold]")
-        rprint(tree)
-
-        if info["tasks"]:
-            rprint(f"\n[bold]Task Details:[/bold]")
-            for task in info["tasks"]:
-                rprint(f"  • {task['name']} ({task['type']})")
-                if task["dependencies"]:
-                    rprint(f"    Dependencies: {', '.join(task['dependencies'])}")
-
-    except ValueError as e:
-        rprint(f"[red]✗[/red] {e}")
-        raise typer.Exit(1)
-
-
-@workflow_app.command("export")
-def workflow_export(
-    workflow_id: Annotated[str, typer.Argument(help="Workflow ID")],
-    output: Annotated[
-        Optional[Path],
-        typer.Option("--output", "-o", help="Output file path (default: stdout)"),
-    ] = None,
-    pretty: Annotated[
-        bool,
-        typer.Option("--pretty", help="Pretty-print JSON"),
-    ] = True,
-) -> None:
-    """Export workflow to JSON IR format."""
-    registry = get_workflow_registry()
-    inspector = WorkflowInspector(registry)
-
-    try:
-        ir = inspector.export_json_ir(workflow_id)
-
-        json_str = json.dumps(ir, indent=2 if pretty else None)
-
-        if output:
-            output.write_text(json_str)
-            rprint(f"[green]✓[/green] Exported workflow to: {output}")
-        else:
-            print(json_str)
-
-    except ValueError as e:
-        rprint(f"[red]✗[/red] {e}")
-        raise typer.Exit(1)
-
-
-# ============ Project Commands ============
-
-project_app = typer.Typer(help="Project management commands")
-app.add_typer(project_app, name="project")
-
-
-@project_app.command("create")
-def project_create(
-    id: Annotated[str, typer.Argument(help="Project ID (slug)")],
-    name: Annotated[str, typer.Option("--name", "-n", help="Project name")],
-    description: Annotated[str, typer.Option("--desc", "-d", help="Description")] = "",
-    owner: Annotated[str, typer.Option("--owner", "-o", help="Owner")] = "",
-    tags: Annotated[
-        Optional[str], typer.Option("--tags", "-t", help="Comma-separated tags")
-    ] = None,
-    path: Annotated[
-        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
-    ] = None,
-) -> None:
-    """Create a new project."""
-    workspace = _get_workspace(path)
-
-    tag_list = [t.strip() for t in tags.split(",")] if tags else []
-
-    try:
-        project = workspace.create_project(
-            id=id,
-            name=name,
-            description=description,
-            owner=owner,
-            tags=tag_list,
-        )
-        rprint(f"[green]✓[/green] Created project: {project.id}")
-        rprint(f"  Name: {project.name}")
-        rprint(f"  Path: {workspace.root / project.path}")
-    except Exception as e:
-        rprint(f"[red]✗[/red] Error: {e}")
-        raise typer.Exit(1)
-
-
-@project_app.command("list")
-def project_list(
-    path: Annotated[
-        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
-    ] = None,
-) -> None:
-    """List all projects."""
-    workspace = _get_workspace(path)
-    projects = workspace.list_projects()
-
-    if not projects:
-        rprint("[yellow]No projects found[/yellow]")
-        return
-
-    table = Table(title="Projects")
-    table.add_column("ID", style="cyan")
-    table.add_column("Name", style="green")
-    table.add_column("Owner")
-    table.add_column("Tags")
-    table.add_column("Created")
-
-    for project in projects:
-        table.add_row(
-            project.id,
-            project.name,
-            project.owner,
-            ", ".join(project.tags),
-            project.created_at.strftime("%Y-%m-%d %H:%M"),
-        )
-
-    console.print(table)
-
-
-@project_app.command("info")
-def project_info(
-    id: Annotated[str, typer.Argument(help="Project ID")],
-    path: Annotated[
-        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
-    ] = None,
-) -> None:
-    """Show project information."""
-    workspace = _get_workspace(path)
-    project = workspace.get_project(id)
-
-    if not project:
-        rprint(f"[red]✗[/red] Project not found: {id}")
-        raise typer.Exit(1)
-
-    rprint(f"[bold]Project:[/bold] {project.id}")
-    rprint(f"  Name: {project.name}")
-    rprint(f"  Description: {project.description}")
-    rprint(f"  Owner: {project.owner}")
-    rprint(f"  Tags: {', '.join(project.tags)}")
-    rprint(f"  Created: {project.created_at}")
-
-    experiments = workspace.list_experiments(id)
-    rprint(f"  Experiments: {len(experiments)}")
-
-
-# ============ Experiment Commands ============
-
-experiment_app = typer.Typer(help="Experiment management commands")
-app.add_typer(experiment_app, name="experiment")
-
-
-@experiment_app.command("create")
-def experiment_create(
-    project_id: Annotated[str, typer.Argument(help="Project ID")],
-    name: Annotated[str, typer.Option("--name", "-n", help="Experiment name")],
-    workflow: Annotated[
-        str, typer.Option("--workflow", "-w", help="Workflow file path")
-    ],
-    description: Annotated[str, typer.Option("--desc", "-d", help="Description")] = "",
-    params: Annotated[
-        Optional[str], typer.Option("--params", help="Parameters JSON")
-    ] = None,
-    path: Annotated[
-        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
-    ] = None,
-) -> None:
-    """Create a new experiment."""
-    workspace = _get_workspace(path)
-
-    try:
-        project = workspace.get_project(project_id)
-        if not project:
-            rprint(f"[red]✗[/red] Project not found: {project_id}")
-            raise typer.Exit(1)
-
-        experiment = project.create_experiment(name=name)
-        if workflow or description or params:
-            rprint(
-                "[yellow]⚠[/yellow] Workflow/description/params are not persisted by the current core model"
-            )
-        rprint(f"[green]✓[/green] Created experiment: {experiment.id}")
-        rprint(f"  Name: {experiment.name}")
-        rprint(f"  Project: {project_id}")
-        rprint(f"  Path: {workspace.root / 'projects' / project_id / 'experiments' / experiment.id}")
-    except Exception as e:
-        rprint(f"[red]✗[/red] Error: {e}")
-        raise typer.Exit(1)
-
-
-@experiment_app.command("list")
-def experiment_list(
-    id: Annotated[str, typer.Argument(help="Project ID")],
-    path: Annotated[
-        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
-    ] = None,
-) -> None:
-    """List all experiments in a project."""
-    workspace = _get_workspace(path)
-    experiments = workspace.list_experiments(id)
-
-    if not experiments:
-        rprint(f"[yellow]No experiments found in project: {id}[/yellow]")
-        return
-
-    table = Table(title=f"Experiments in {id}")
-    table.add_column("ID", style="cyan")
-    table.add_column("Name", style="green")
-    table.add_column("Workflow")
-    table.add_column("Created")
-
-    for exp in experiments:
-        table.add_row(
-            exp.id,
-            exp.name,
-            exp.workflow_template.source,
-            exp.created_at.strftime("%Y-%m-%d %H:%M"),
-        )
-
-    console.print(table)
-
-
-# ============ Run Commands ============
-
-run_app = typer.Typer(help="Run management commands")
-app.add_typer(run_app, name="run")
-
-
-@run_app.command("create")
-def run_create(
-    project_id: Annotated[str, typer.Argument(help="Project ID")],
-    experiment_id: Annotated[str, typer.Argument(help="Experiment ID")],
-    params: Annotated[
-        Optional[str],
-        typer.Option("--params", help="Parameters JSON string or file path"),
-    ] = None,
-    path: Annotated[
-        Optional[Path],
-        typer.Option("--path", "-p", help="Workspace path"),
-    ] = None,
-) -> None:
-    """Create a new run."""
-    workspace = _get_workspace(path)
-
-    # Parse parameters
-    parameters = {}
-    if params:
-        # Check if it's a file path
-        params_path = Path(params)
-        if params_path.exists():
-            parameters = json.loads(params_path.read_text())
-        else:
-            # Try to parse as JSON string
-            try:
-                parameters = json.loads(params)
-            except json.JSONDecodeError:
-                rprint(f"[red]✗[/red] Invalid JSON in parameters: {params}")
-                raise typer.Exit(1)
-
-    try:
-        # Get experiment to get workflow info
-        experiment = workspace.get_experiment(id, id)
-        if not experiment:
-            rprint(f"[red]✗[/red] Experiment not found: {id}/{id}")
-            raise typer.Exit(1)
-
-        run = workspace.create_run(
-            id=id,
-            parameters=parameters,
-            workflow_file=experiment.workflow_template.source,
-            git_commit=experiment.workflow_template.git_commit,
-        )
-
-        rprint(f"[green]✓[/green] Created run: {run.id}")
-        rprint(f"  Project: {project_id}")
-        rprint(f"  Experiment: {experiment_id}")
-        rprint(f"  Status: {run.status.value}")
-        rprint(f"  Parameters: {json.dumps(parameters, indent=2)}")
-
-    except Exception as e:
-        rprint(f"[red]✗[/red] Error: {e}")
-        raise typer.Exit(1)
-
-
-@run_app.command("list")
-def run_list(
-    project_id: Annotated[str, typer.Argument(help="Project ID")],
-    experiment_id: Annotated[str, typer.Argument(help="Experiment ID")],
-    path: Annotated[
-        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
-    ] = None,
-) -> None:
-    """List all runs in an experiment."""
-    workspace = _get_workspace(path)
-    runs = workspace.list_runs(id, id)
-
-    if not runs:
-        rprint(f"[yellow]No runs found in {id}/{id}[/yellow]")
-        return
-
-    table = Table(title=f"Runs in {id}/{id}")
-    table.add_column("Run ID", style="cyan")
-    table.add_column("Status", style="green")
-    table.add_column("Created")
-    table.add_column("Duration")
-
-    for run in runs:
-        duration = ""
-        if run.finished_at:
-            delta = run.finished_at - run.created_at
-            duration = f"{delta.total_seconds():.1f}s"
-
-        status_color = {
-            "succeeded": "green",
-            "failed": "red",
-            "running": "yellow",
-            "pending": "blue",
-            "cancelled": "gray",
-        }.get(run.status.value, "white")
-
-        table.add_row(
-            run.id,
-            f"[{status_color}]{run.status.value}[/{status_color}]",
-            run.created_at.strftime("%Y-%m-%d %H:%M:%S"),
-            duration,
-        )
-
-    console.print(table)
-
-
-@run_app.command("info")
-def run_info(
-    project_id: Annotated[str, typer.Argument(help="Project ID")],
-    experiment_id: Annotated[str, typer.Argument(help="Experiment ID")],
-    run_id: Annotated[str, typer.Argument(help="Run ID")],
-    path: Annotated[
-        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
-    ] = None,
-) -> None:
-    """Show run information."""
-    workspace = _get_workspace(path)
-    run = workspace.get_run(project_id, experiment_id, run_id)
-
-    if not run:
-        rprint(f"[red]✗[/red] Run not found: {id}")
-        raise typer.Exit(1)
-
-    rprint(f"[bold]Run:[/bold] {run.id}")
-    rprint(f"  Status: {run.status.value}")
-    rprint(f"  Created: {run.created_at}")
-    rprint(f"  Finished: {run.finished_at or 'N/A'}")
-    rprint(f"  Workflow: {run.workflow_snapshot.workflow_file}")
-    rprint(f"  Parameters: {json.dumps(run.parameters, indent=2)}")
-
-    # Show asset refs
-    refs = workspace.get_asset_refs(id, id, id)
-    if refs:
-        rprint(f"\n[bold]Assets:[/bold]")
-        rprint(f"  Inputs: {len(refs.inputs)}")
-        rprint(f"  Outputs: {len(refs.outputs)}")
-
-
-# ============ Asset Commands ============
-
-asset_app = typer.Typer(help="Asset management commands")
-app.add_typer(asset_app, name="asset")
-
-
-@asset_app.command("list")
-def asset_list(
-    path: Annotated[
-        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
-    ] = None,
-    limit: Annotated[int, typer.Option("--limit", "-l", help="Limit results")] = 50,
-) -> None:
-    """List all assets."""
-    workspace = _get_workspace(path)
-    assets = workspace.list_assets()[:limit]
-
-    if not assets:
-        rprint("[yellow]No assets found[/yellow]")
-        return
-
-    table = Table(title="Assets")
-    table.add_column("Asset ID", style="cyan")
-    table.add_column("Type", style="green")
-    table.add_column("Format")
-    table.add_column("Size")
-    table.add_column("Created")
-
-    for asset in assets:
-        size_mb = asset.size_bytes / (1024 * 1024)
-        table.add_row(
-            asset.asset_id[:8] + "...",
-            asset.type.value,
-            asset.format,
-            f"{size_mb:.2f} MB",
-            asset.created_at.strftime("%Y-%m-%d %H:%M"),
-        )
-
-    console.print(table)
-
-
-@asset_app.command("info")
-def asset_info(
-    asset_id: Annotated[str, typer.Argument(help="Asset ID")],
-    path: Annotated[
-        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
-    ] = None,
-) -> None:
-    """Show asset information."""
-    workspace = _get_workspace(path)
-    asset = workspace.get_asset(asset_id)
-
-    if not asset:
-        rprint(f"[red]✗[/red] Asset not found: {asset_id}")
-        raise typer.Exit(1)
-
-    rprint(f"[bold]Asset:[/bold] {asset.asset_id}")
-    rprint(f"  Type: {asset.type.value}")
-    rprint(f"  Format: {asset.format}")
-    rprint(f"  Size: {asset.size_bytes / (1024 * 1024):.2f} MB")
-    rprint(f"  Hash: {asset.content_hash}")
-    rprint(f"  Created: {asset.created_at}")
-    rprint(f"  Producer: {asset.producer_id or 'N/A'}")
-    rprint(f"  Tags: {', '.join(asset.tags)}")
-    rprint(f"  Files: {len(asset.files)}")
-
-
-# ============ Helper Functions ============
-
-
-def _get_workspace(path: Path | None = None) -> Workspace:
-    """Get workspace from path or environment."""
-    if path:
-        return Workspace.from_path(path)
-    return Workspace.from_env()
+# Order matters only for --help display. Import for side-effect registration.
+from molexp.cli import (  # noqa: E402,F401
+    run_cmd,
+    serve_cmd,
+    workspace_cmd,
+    watch_cmd,
+    project,
+    experiment,
+    runs,
+    asset,
+)
 
 
 if __name__ == "__main__":
diff --git a/src/molexp/cli/__main__.py b/src/molexp/cli/__main__.py
new file mode 100644
index 00000000..2e877811
--- /dev/null
+++ b/src/molexp/cli/__main__.py
@@ -0,0 +1,4 @@
+"""Allow ``python -m molexp.cli`` invocation."""
+from molexp.cli import app
+
+app()
diff --git a/src/molexp/cli/__pycache__/__init__.cpython-312.pyc b/src/molexp/cli/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index b8c8c45f..00000000
Binary files a/src/molexp/cli/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/cli/_common.py b/src/molexp/cli/_common.py
new file mode 100644
index 00000000..6369eee5
--- /dev/null
+++ b/src/molexp/cli/_common.py
@@ -0,0 +1,124 @@
+"""Shared helpers for the molexp CLI.
+
+Everything in this module is internal — command modules import from it.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import platform
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from rich import print as rprint
+from rich.console import Console
+
+from molexp.plugins.submit_molq.metadata import normalize_executor_info
+from molexp.workspace import Workspace
+
+console = Console()
+
+# Terminal run statuses — not cancellable / considered "done".
+_TERMINAL_STATUSES = frozenset({"succeeded", "failed", "cancelled"})
+
+# Rich color mapping used by list / info / monitor displays.
+_STATUS_COLORS: dict[str, str] = {
+    "succeeded": "green",
+    "failed": "red",
+    "running": "yellow",
+    "pending": "blue",
+    "cancelled": "gray",
+}
+
+
+def status_color(status: str) -> str:
+    """Return the rich color for a run status (white if unknown)."""
+    return _STATUS_COLORS.get(str(status).lower(), "white")
+
+
+def get_workspace(path: Path | None = None) -> Workspace:
+    """Load the workspace at *path* (default: current directory)."""
+    return Workspace(path or Path.cwd())
+
+
+def deterministic_run_id(params: dict[str, Any]) -> str:
+    """Generate a deterministic 16-char run ID from parameters.
+
+    Same parameters always produce the same ID, making run creation
+    idempotent across repeated ``molexp run`` invocations.  The caller
+    decides which fields to include (for profile-aware IDs, mix in
+    the profile name / config hash).
+    """
+    raw = "|".join(f"{k}={v!r}" for k, v in sorted(params.items()))
+    return hashlib.sha256(raw.encode()).hexdigest()[:16]
+
+
+def pid_alive(pid: int) -> bool:
+    """Return ``True`` if a process with *pid* exists on this host."""
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+def reap_zombie_run(run: Any) -> bool:
+    """Mark a stale ``RUNNING`` run as ``FAILED`` if its owner is dead.
+
+    Returns ``True`` when the run was reaped (status flipped from
+    ``running`` to ``failed``), ``False`` when a live owner is detected.
+    """
+    from molexp.workspace.models import ErrorInfo
+    from molexp.workspace.run import RunStatus
+
+    labels = dict(run.metadata.labels)
+    pid_str = labels.get("pid")
+    host = labels.get("host")
+    same_host = host == platform.node()
+
+    if same_host and pid_str and pid_str.isdigit() and pid_alive(int(pid_str)):
+        return False
+
+    now = datetime.now()
+    for key in ("pid", "host", "heartbeat"):
+        labels.pop(key, None)
+    run._update_metadata(
+        status=RunStatus.FAILED,
+        finished_at=now,
+        labels=labels,
+        error=ErrorInfo(
+            type="ZombieRun",
+            message=(
+                f"Run was left in 'running' state by a prior invocation "
+                f"(pid={pid_str or '?'} host={host or '?'}) that did not "
+                "finish cleanly.  Automatically marked FAILED."
+            ),
+            timestamp=now,
+        ),
+    )
+    return True
+
+
+def run_executor_info(run: Any) -> dict[str, str]:
+    """Return normalized executor metadata for a workspace run."""
+    return normalize_executor_info(run.metadata.executor_info, run.metadata.labels)
+
+
+__all__ = [
+    "console",
+    "rprint",
+    "_TERMINAL_STATUSES",
+    "_STATUS_COLORS",
+    "status_color",
+    "get_workspace",
+    "deterministic_run_id",
+    "pid_alive",
+    "reap_zombie_run",
+    "run_executor_info",
+]
diff --git a/src/molexp/cli/asset.py b/src/molexp/cli/asset.py
new file mode 100644
index 00000000..22220eea
--- /dev/null
+++ b/src/molexp/cli/asset.py
@@ -0,0 +1,45 @@
+"""``molexp asset ...`` — asset management sub-commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.table import Table
+
+from . import app
+from ._common import console, get_workspace, rprint
+
+asset_app = typer.Typer(help="Asset management commands")
+app.add_typer(asset_app, name="asset")
+
+
+@asset_app.command("list")
+def asset_list(
+    path: Annotated[
+        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
+    ] = None,
+    limit: Annotated[int, typer.Option("--limit", "-l", help="Limit results")] = 50,
+) -> None:
+    """List workspace-level assets."""
+    ws = get_workspace(path)
+    assets = ws.assets.list_assets()[:limit]
+
+    if not assets:
+        rprint("[yellow]No assets found[/yellow]")
+        return
+
+    table = Table(title="Workspace Assets")
+    table.add_column("Asset ID", style="cyan")
+    table.add_column("Name", style="green")
+    table.add_column("Created")
+
+    for a in assets:
+        table.add_row(
+            a.asset_id[:12] + "...",
+            a.name,
+            a.created_at.strftime("%Y-%m-%d %H:%M"),
+        )
+
+    console.print(table)
diff --git a/src/molexp/cli/experiment.py b/src/molexp/cli/experiment.py
new file mode 100644
index 00000000..4916a299
--- /dev/null
+++ b/src/molexp/cli/experiment.py
@@ -0,0 +1,79 @@
+"""``molexp experiment ...`` — experiment management sub-commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.table import Table
+
+from . import app
+from ._common import console, get_workspace, rprint
+
+experiment_app = typer.Typer(help="Experiment management commands")
+app.add_typer(experiment_app, name="experiment")
+
+
+@experiment_app.command("create")
+def experiment_create(
+    project_id: Annotated[str, typer.Argument(help="Project ID")],
+    name: Annotated[str, typer.Option("--name", "-n", help="Experiment name")],
+    path: Annotated[
+        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
+    ] = None,
+) -> None:
+    """Create a new experiment."""
+    ws = get_workspace(path)
+
+    try:
+        project = ws.get_project(project_id)
+        if not project:
+            rprint(f"[red]Error:[/red] Project not found: {project_id}")
+            raise typer.Exit(1)
+
+        experiment = project.experiment(name)
+        rprint(f"[green]OK[/green] Created experiment: {experiment.id}")
+        rprint(f"  Name: {experiment.name}")
+        rprint(f"  Project: {project_id}")
+    except typer.Exit:
+        raise
+    except Exception as e:
+        rprint(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@experiment_app.command("list")
+def experiment_list(
+    project_id: Annotated[str, typer.Argument(help="Project ID")],
+    path: Annotated[
+        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
+    ] = None,
+) -> None:
+    """List all experiments in a project."""
+    ws = get_workspace(path)
+    project = ws.get_project(project_id)
+
+    if not project:
+        rprint(f"[red]Error:[/red] Project not found: {project_id}")
+        raise typer.Exit(1)
+
+    experiments = project.list_experiments()
+
+    if not experiments:
+        rprint(f"[yellow]No experiments found in project: {project_id}[/yellow]")
+        return
+
+    table = Table(title=f"Experiments in {project_id}")
+    table.add_column("ID", style="cyan")
+    table.add_column("Name", style="green")
+    table.add_column("Created")
+
+    for exp in experiments:
+        table.add_row(
+            exp.id,
+            exp.name,
+            exp.created_at.strftime("%Y-%m-%d %H:%M"),
+        )
+
+    console.print(table)
diff --git a/src/molexp/cli/project.py b/src/molexp/cli/project.py
new file mode 100644
index 00000000..5da51630
--- /dev/null
+++ b/src/molexp/cli/project.py
@@ -0,0 +1,93 @@
+"""``molexp project ...`` — project management sub-commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.table import Table
+
+from . import app
+from ._common import console, get_workspace, rprint
+
+project_app = typer.Typer(help="Project management commands")
+app.add_typer(project_app, name="project")
+
+
+@project_app.command("create")
+def project_create(
+    name: Annotated[str, typer.Argument(help="Project name")],
+    path: Annotated[
+        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
+    ] = None,
+) -> None:
+    """Create a new project."""
+    ws = get_workspace(path)
+
+    try:
+        project = ws.project(name)
+        rprint(f"[green]OK[/green] Created project: {project.id}")
+        rprint(f"  Name: {project.name}")
+    except Exception as e:
+        rprint(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@project_app.command("list")
+def project_list(
+    path: Annotated[
+        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
+    ] = None,
+) -> None:
+    """List all projects."""
+    ws = get_workspace(path)
+    projects = ws.list_projects()
+
+    if not projects:
+        rprint("[yellow]No projects found[/yellow]")
+        return
+
+    table = Table(title="Projects")
+    table.add_column("ID", style="cyan")
+    table.add_column("Name", style="green")
+    table.add_column("Owner")
+    table.add_column("Tags")
+    table.add_column("Created")
+
+    for project in projects:
+        table.add_row(
+            project.id,
+            project.name,
+            project.owner,
+            ", ".join(project.tags),
+            project.created_at.strftime("%Y-%m-%d %H:%M"),
+        )
+
+    console.print(table)
+
+
+@project_app.command("info")
+def project_info(
+    project_id: Annotated[str, typer.Argument(help="Project ID")],
+    path: Annotated[
+        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
+    ] = None,
+) -> None:
+    """Show project information."""
+    ws = get_workspace(path)
+    project = ws.get_project(project_id)
+
+    if not project:
+        rprint(f"[red]Error:[/red] Project not found: {project_id}")
+        raise typer.Exit(1)
+
+    rprint(f"[bold]Project:[/bold] {project.id}")
+    rprint(f"  Name: {project.name}")
+    rprint(f"  Description: {project.description}")
+    rprint(f"  Owner: {project.owner}")
+    rprint(f"  Tags: {', '.join(project.tags)}")
+    rprint(f"  Created: {project.created_at}")
+
+    experiments = project.list_experiments()
+    rprint(f"  Experiments: {len(experiments)}")
diff --git a/src/molexp/cli/run_cmd.py b/src/molexp/cli/run_cmd.py
new file mode 100644
index 00000000..463f444c
--- /dev/null
+++ b/src/molexp/cli/run_cmd.py
@@ -0,0 +1,657 @@
+"""``molexp run`` — execute workflows defined by a Python script."""
+
+from __future__ import annotations
+
+import asyncio
+import traceback
+from pathlib import Path
+from typing import Annotated, Any, Callable, Optional
+
+import typer
+
+from molexp.config import MolCfg, ProfileConfig, load_molcfg
+from molexp.config.loader import find_default_config
+
+from . import app
+from ._common import (
+    console,
+    deterministic_run_id,
+    reap_zombie_run,
+    rprint,
+)
+
+RunHandler = Callable[[Any, Any, Any], None]
+
+
+# ── Config / profile resolution ─────────────────────────────────────────────
+
+
+def _coerce_value(raw: str) -> Any:
+    """Coerce a string CLI value to int, float, bool, or str."""
+    if raw.lower() == "true":
+        return True
+    if raw.lower() == "false":
+        return False
+    try:
+        return int(raw)
+    except ValueError:
+        pass
+    try:
+        return float(raw)
+    except ValueError:
+        pass
+    return raw
+
+
+def _set_nested(d: dict[str, Any], key_path: str, value: Any) -> None:
+    """Set a nested dict value using dot-notation key path (mutates *d*)."""
+    parts = key_path.split(".")
+    node = d
+    for part in parts[:-1]:
+        if part not in node or not isinstance(node[part], dict):
+            node[part] = {}
+        node = node[part]
+    node[parts[-1]] = value
+
+
+def _apply_overrides(
+    profile_cfg: ProfileConfig,
+    overrides: list[str],
+) -> ProfileConfig:
+    """Return a new :class:`ProfileConfig` with *overrides* applied on top.
+
+    Each entry in *overrides* must be a ``KEY=VALUE`` string.  Dot notation
+    is supported for nested keys (e.g. ``model.n_layers=3``).  Values are
+    coerced to ``bool``, ``int``, ``float``, or ``str`` in that priority.
+
+    Raises :class:`typer.Exit` with an error message on malformed entries.
+    """
+    if not overrides:
+        return profile_cfg
+    data = profile_cfg.to_dict()
+    for item in overrides:
+        if "=" not in item:
+            rprint(
+                f"[red]Error:[/red] --set value {item!r} is not in KEY=VALUE format."
+            )
+            raise typer.Exit(1)
+        key, _, raw = item.partition("=")
+        key = key.strip()
+        if not key:
+            rprint(f"[red]Error:[/red] --set value {item!r} has an empty key.")
+            raise typer.Exit(1)
+        _set_nested(data, key, _coerce_value(raw))
+    return ProfileConfig(data, name=profile_cfg.name)
+
+
+def _resolve_profile(
+    config_path: Path | None, profile: str | None
+) -> ProfileConfig:
+    """Load molcfg and resolve the requested profile.
+
+    - If *config_path* is given it must exist.
+    - Otherwise we look for a default ``molcfg.yaml`` / ``.yml`` / ``.json``
+      in the current working directory.
+    - If no file is found and no *profile* is requested, return an
+      empty :class:`ProfileConfig` (defaults-only, name=None).
+    - If no file is found but *profile* is requested, abort.
+    """
+    resolved_path: Path | None
+    if config_path is not None:
+        resolved_path = config_path
+    else:
+        resolved_path = find_default_config()
+
+    if resolved_path is None:
+        if profile is not None:
+            rprint(
+                f"[red]Error:[/red] --profile {profile!r} was requested but "
+                "no config file was found (searched for ./molcfg.yaml / .yml / .json)."
+            )
+            raise typer.Exit(1)
+        return ProfileConfig({}, name=None)
+
+    try:
+        cfg: MolCfg = load_molcfg(resolved_path)
+    except Exception as exc:
+        rprint(f"[red]Error:[/red] failed to load config {resolved_path}: {exc}")
+        raise typer.Exit(1)
+
+    try:
+        return cfg.resolve(profile)
+    except KeyError as exc:
+        rprint(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)
+
+
+# ── Sweep driver ────────────────────────────────────────────────────────────
+
+
+def _execute_sweep(
+    *,
+    script: Path,
+    profile_cfg: ProfileConfig,
+    resume: bool,
+    workspace: Path | None,
+    run_handler: RunHandler,
+    mode_label: str,
+    suppress_ok: bool = False,
+) -> tuple[int, list[Any]]:
+    """Walk each workspace's experiments and dispatch one run per replica.
+
+    Idempotent: re-running with the same script produces deterministic
+    run IDs (derived from parameters + active profile) so repeated
+    invocations skip already-executed replicas unless ``--resume`` is
+    set, in which case non-succeeded runs of the matching profile are
+    replayed.
+    """
+    from molexp.entry import load_workspaces
+
+    try:
+        workspaces = load_workspaces(script)
+    except Exception as exc:
+        rprint(f"[red]Error importing {script.name}:[/red] {exc}")
+        rprint(traceback.format_exc(), end="")
+        raise typer.Exit(1)
+
+    if not workspaces:
+        rprint(
+            "[red]Error:[/red] No me.entry() call found in script. "
+            "Add [bold]me.entry(workspace)[/bold] at module level."
+        )
+        raise typer.Exit(1)
+
+    total_dispatched = 0
+    dispatched_runs: list[Any] = []
+
+    for ws in workspaces:
+        if workspace is not None:
+            override = Path(workspace).resolve()
+            if override != ws.root:
+                rprint(
+                    f"[yellow]Warning:[/yellow] --workspace {override} differs from "
+                    f"script's Workspace root {ws.root}; using the script's workspace."
+                )
+
+        for project in ws.list_projects():
+            for exp in project.list_experiments():
+                if exp.workflow is None:
+                    rprint(
+                        f"[red]Error:[/red] Experiment {exp.name!r} has no workflow. "
+                        "Call experiment.set_workflow(fn) before me.entry()."
+                    )
+                    raise typer.Exit(1)
+
+                seeds = exp.get_seeds()
+                total = exp.n_replicas
+                label = f"[cyan]resume[/cyan] + {mode_label}" if resume else mode_label
+                profile_display = profile_cfg.name or "(defaults)"
+                rprint(
+                    f"\n[bold]Experiment:[/bold] {exp.name}"
+                    f"\n  Script:    {script}"
+                    f"\n  Workspace: {ws.root}"
+                    f"\n  Project:   {project.name}"
+                    f"\n  Profile:   {profile_display}"
+                    f"\n  Runs:      {total} replicas"
+                    f"\n  Mode:      {label}"
+                )
+
+                created_runs: list[tuple[Any, int]] = []
+
+                for replica_idx, seed in enumerate(seeds):
+                    run_params = {**exp.params, "seed": seed, "replica": replica_idx}
+                    # Profile name and config hash are folded into the ID
+                    # so different profiles of the same replica do not
+                    # collide under the same run directory.
+                    id_seed = dict(run_params)
+                    if profile_cfg.name is not None:
+                        id_seed["_profile"] = profile_cfg.name
+                        id_seed["_config_hash"] = profile_cfg.content_hash()
+                    run_id = deterministic_run_id(id_seed)
+
+                    existing = exp.get_run(run_id)
+                    if existing is not None and existing.status == "running":
+                        if reap_zombie_run(existing):
+                            rprint(
+                                f"  [yellow]![/yellow] {exp.id}  seed={seed} "
+                                "(stale 'running' run reaped → failed)"
+                            )
+
+                    if resume:
+                        if existing is None:
+                            rprint(f"  [dim]- {exp.id}  seed={seed} (no existing run, skipped)[/dim]")
+                            continue
+                        # Resume all non-succeeded runs that match this profile.
+                        if existing.status == "succeeded":
+                            rprint(f"  [dim]- {exp.id}  seed={seed} (already succeeded, skipped)[/dim]")
+                            continue
+                        if existing.metadata.profile != profile_cfg.name:
+                            rprint(
+                                f"  [dim]- {exp.id}  seed={seed} (profile mismatch: "
+                                f"{existing.metadata.profile!r} vs {profile_cfg.name!r}, skipped)[/dim]"
+                            )
+                            continue
+                        mol_run = existing
+                    elif existing is not None:
+                        if existing.status in ("succeeded", "running"):
+                            rprint(f"  [dim]- {exp.id}  seed={seed} ({existing.status}, skipped)[/dim]")
+                            continue
+                        mol_run = existing
+                    else:
+                        mol_run = exp.run(parameters=run_params, id=run_id)
+
+                    created_runs.append((mol_run, seed))
+                    icon = "[cyan]>[/cyan]" if resume else "[dim]o[/dim]"
+                    rprint(f"  {icon} {exp.id}  seed={seed}")
+
+                for mol_run, seed in created_runs:
+                    # Persist script path and profile config into run.json before
+                    # any handler so the worker can reconstruct everything from
+                    # run_dir alone (via ``molexp execute <run_dir>``).
+                    mol_run._update_metadata(
+                        script=str(script.resolve()),
+                        profile=profile_cfg.name,
+                        config=profile_cfg.to_dict(),
+                        config_hash=(
+                            profile_cfg.content_hash()
+                            if len(profile_cfg) > 0 or profile_cfg.name
+                            else None
+                        ),
+                    )
+                    run_handler(mol_run, exp, project)
+                    dispatched_runs.append(mol_run)
+                    rprint(f"  [cyan]>[/cyan] dispatched {exp.id}  seed={seed}")
+
+                total_dispatched += len(created_runs)
+                if not suppress_ok:
+                    verb = "resumed" if resume else "completed"
+                    rprint(f"\n[green]OK[/green] {len(created_runs)} runs {verb}.")
+
+    return total_dispatched, dispatched_runs
+
+
+# ── Background launcher ─────────────────────────────────────────────────────
+
+
+def _launch_bg(
+    *,
+    script: Path,
+    config_path: Path | None,
+    profile: str | None,
+    overrides: list[str],
+    resume: bool,
+    workspace: Path | None,
+) -> None:
+    """Fork a detached subprocess that re-runs the sweep without ``--bg``."""
+    import subprocess
+    import sys
+
+    cmd = [sys.executable, "-m", "molexp.cli", "run", str(script), "--local"]
+    if config_path is not None:
+        cmd.extend(["--config", str(config_path)])
+    if profile is not None:
+        cmd.extend(["--profile", profile])
+    for override in overrides:
+        cmd.extend(["--override", override])
+    if resume:
+        cmd.append("--resume")
+    if workspace is not None:
+        cmd.extend(["--workspace", str(workspace)])
+
+    ws_root = Path(workspace).resolve() if workspace else Path.cwd()
+    ws_root.mkdir(parents=True, exist_ok=True)
+
+    proc = subprocess.Popen(
+        cmd,
+        stdout=open(ws_root / "molexp_bg.log", "a"),
+        stderr=subprocess.STDOUT,
+        stdin=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    rprint(
+        f"[green]OK[/green] Launched in background (pid={proc.pid}). "
+        f"Logs: [bold]{ws_root / 'molexp_bg.log'}[/bold]"
+    )
+
+
+# ── Typer argument / option aliases ─────────────────────────────────────────
+
+_SCRIPT_ARG = Annotated[
+    Path,
+    typer.Argument(
+        help="Python script with me.entry(project) call.",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        resolve_path=True,
+    ),
+]
+
+
+# ── Command ─────────────────────────────────────────────────────────────────
+
+
+@app.command()
+def run(
+    script: _SCRIPT_ARG,
+    # ── Execution backend ──────────────────────────────────────────────────
+    local: Annotated[
+        bool,
+        typer.Option("--local", help="Run locally, sequentially (default).", rich_help_panel="Execution Backend"),
+    ] = False,
+    slurm: Annotated[
+        bool,
+        typer.Option("--slurm", help="Submit to a SLURM cluster via molq.", rich_help_panel="Execution Backend"),
+    ] = False,
+    pbs: Annotated[
+        bool,
+        typer.Option("--pbs", help="Submit to a PBS/Torque cluster via molq.", rich_help_panel="Execution Backend"),
+    ] = False,
+    lsf: Annotated[
+        bool,
+        typer.Option("--lsf", help="Submit to an LSF cluster via molq.", rich_help_panel="Execution Backend"),
+    ] = False,
+    scheduler: Annotated[
+        Optional[str],
+        typer.Option(
+            "--scheduler",
+            help="Submit via a molq scheduler backend (e.g. local, slurm, pbs, lsf).",
+            rich_help_panel="Execution Backend",
+        ),
+    ] = None,
+    # ── Config / profile ───────────────────────────────────────────────────
+    config: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--config",
+            "-c",
+            help=(
+                "Path to molcfg file (YAML or JSON). "
+                "Defaults to ./molcfg.yaml / .yml / .json if present."
+            ),
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            resolve_path=True,
+        ),
+    ] = None,
+    profile: Annotated[
+        Optional[str],
+        typer.Option(
+            "--profile",
+            help=(
+                "Named molcfg profile to activate (e.g. 'dry-run', 'smoke'). "
+                "Profile names with '-' are normalized to '_'."
+            ),
+        ),
+    ] = None,
+    overrides: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--override",
+            help=(
+                "Override a config key after profile resolution. "
+                "Format: KEY=VALUE (repeatable). "
+                "Dot notation supported for nested keys: model.n_layers=3. "
+                "Values are auto-coerced to bool/int/float/str."
+            ),
+        ),
+    ] = None,
+    # ── Common options ─────────────────────────────────────────────────────
+    resume: Annotated[
+        bool,
+        typer.Option(
+            "--resume",
+            help=(
+                "Re-execute non-succeeded runs whose profile matches the "
+                "one selected by --profile."
+            ),
+        ),
+    ] = False,
+    bg: Annotated[
+        bool,
+        typer.Option("--bg", help="Run in background (local only). Logs to <workspace>/molexp_bg.log."),
+    ] = False,
+    workspace: Annotated[
+        Optional[Path],
+        typer.Option("--workspace", "-w", help="Workspace root (overrides project config)."),
+    ] = None,
+    # ── HPC options (slurm / pbs / lsf) ───────────────────────────────────
+    cpus: Annotated[
+        Optional[int],
+        typer.Option("--cpus", help="CPU cores per job.", rich_help_panel="HPC Options"),
+    ] = None,
+    mem: Annotated[
+        Optional[str],
+        typer.Option("--mem", help="Memory per job (e.g. 8G, 512M).", rich_help_panel="HPC Options"),
+    ] = None,
+    time: Annotated[
+        Optional[str],
+        typer.Option("--time", "-t", help="Wall-clock time limit (e.g. 12:00:00, 2h30m).", rich_help_panel="HPC Options"),
+    ] = None,
+    gpus: Annotated[
+        Optional[int],
+        typer.Option("--gpus", help="GPUs per job.", rich_help_panel="HPC Options"),
+    ] = None,
+    gpu_type: Annotated[
+        Optional[str],
+        typer.Option("--gpu-type", help="GPU type constraint (e.g. a100).", rich_help_panel="HPC Options"),
+    ] = None,
+    account: Annotated[
+        Optional[str],
+        typer.Option("--account", "-A", help="Account / project name.", rich_help_panel="HPC Options"),
+    ] = None,
+    cluster: Annotated[
+        Optional[str],
+        typer.Option("--cluster", help="molq cluster name.", rich_help_panel="HPC Options"),
+    ] = None,
+    # ── SLURM-specific ─────────────────────────────────────────────────────
+    partition: Annotated[
+        Optional[str],
+        typer.Option("--partition", "-p", help="SLURM partition.", rich_help_panel="SLURM Options"),
+    ] = None,
+    qos: Annotated[
+        Optional[str],
+        typer.Option("--qos", help="SLURM QOS.", rich_help_panel="SLURM Options"),
+    ] = None,
+    # ── PBS / LSF-specific ─────────────────────────────────────────────────
+    queue: Annotated[
+        Optional[str],
+        typer.Option("--queue", "-q", help="PBS/LSF queue name.", rich_help_panel="PBS / LSF Options"),
+    ] = None,
+    # ── Monitor ────────────────────────────────────────────────────────────
+    block: Annotated[
+        bool,
+        typer.Option(
+            "--block",
+            help=(
+                "Block after cluster submission and open the interactive "
+                "run monitor until all jobs finish (press q to close)."
+            ),
+            rich_help_panel="HPC Options",
+        ),
+    ] = False,
+) -> None:
+    """Execute the workflow(s) defined by *script*."""
+    # ── Backend selection ──────────────────────────────────────────────────
+    legacy_schedulers = [n for n, flag in (("slurm", slurm), ("pbs", pbs), ("lsf", lsf)) if flag]
+    if len(legacy_schedulers) > 1:
+        rprint(
+            f"[red]Error:[/red] Specify at most one of "
+            f"{', '.join('--' + n for n in legacy_schedulers)}."
+        )
+        raise typer.Exit(1)
+
+    selected_scheduler = scheduler or (legacy_schedulers[0] if legacy_schedulers else None)
+    if local and selected_scheduler is not None:
+        rprint(
+            "[red]Error:[/red] Specify at most one backend flag "
+            "(--local, --scheduler, --slurm, --pbs, --lsf)."
+        )
+        raise typer.Exit(1)
+
+    is_local = selected_scheduler is None
+
+    if bg and not is_local:
+        rprint("[red]Error:[/red] --bg is only valid with --local.")
+        raise typer.Exit(1)
+
+    profile_cfg = _resolve_profile(config, profile)
+    profile_cfg = _apply_overrides(profile_cfg, overrides or [])
+
+    # ── Local execution ────────────────────────────────────────────────────
+    if is_local:
+        if bg:
+            _launch_bg(
+                script=script,
+                config_path=config,
+                profile=profile,
+                overrides=overrides or [],
+                resume=resume,
+                workspace=workspace,
+            )
+            return
+
+        profile_label = f"[cyan]{profile_cfg.name}[/cyan]" if profile_cfg.name else "[dim](defaults)[/dim]"
+        label = f"[green]local[/green] profile={profile_label}"
+
+        def _local_handler(mol_run: Any, experiment: Any, _project: Any) -> None:
+            asyncio.run(
+                experiment.workflow.execute(run=mol_run, profile_config=profile_cfg)
+            )
+
+        _execute_sweep(
+            script=script,
+            profile_cfg=profile_cfg,
+            resume=resume,
+            workspace=workspace,
+            run_handler=_local_handler,
+            mode_label=label,
+        )
+        return
+
+    # ── Cluster backends ───────────────────────────────────────────────────
+    try:
+        from molexp.plugins.submit_molq.metadata import supported_schedulers
+        from molexp.plugins.submit_molq.submit import make_submit_handler
+    except ImportError:
+        rprint(
+            "[red]Error:[/red] molq is not installed. "
+            "Install it to use cluster backends: [bold]pip install molq[/bold]"
+        )
+        raise typer.Exit(1)
+
+    available_schedulers = supported_schedulers()
+    if not available_schedulers:
+        rprint(
+            "[red]Error:[/red] molq is not installed. "
+            "Install it to use cluster backends: [bold]pip install molq[/bold]"
+        )
+        raise typer.Exit(1)
+    if available_schedulers and selected_scheduler not in available_schedulers:
+        supported_text = ", ".join(available_schedulers)
+        rprint(
+            f"[red]Error:[/red] Unsupported molq scheduler: {selected_scheduler!r}. "
+            f"Available: {supported_text}"
+        )
+        raise typer.Exit(1)
+
+    selected_queue = partition if partition is not None else queue
+    handler = make_submit_handler(
+        scheduler=selected_scheduler,
+        cluster=cluster,
+        resources={"cpus": cpus, "mem": mem, "gpus": gpus, "gpu_type": gpu_type, "time": time},
+        scheduling={"queue": selected_queue, "account": account, "qos": qos},
+    )
+    profile_label = f"[cyan]{profile_cfg.name}[/cyan]" if profile_cfg.name else "[dim](defaults)[/dim]"
+    mode_label = f"[magenta]{selected_scheduler}[/magenta] profile={profile_label}"
+
+    n, submitted = _execute_sweep(
+        script=script,
+        profile_cfg=profile_cfg,
+        resume=resume,
+        workspace=workspace,
+        run_handler=handler,
+        mode_label=mode_label,
+        suppress_ok=True,
+    )
+
+    if n == 0:
+        verb = "resumed" if resume else "submitted"
+        rprint(f"\n[dim]No runs {verb}.[/dim]")
+        return
+
+    if block and submitted:
+        from molexp.monitor import RunMonitor
+        rprint(f"\n[dim]Submitted {n} runs. Opening monitor… (press q to close)[/dim]")
+        RunMonitor(title=f"{script.stem}  [{mode_label}]").watch(submitted)
+        rprint(f"\n[dim]Monitor closed. {n} runs are still executing (if any).[/dim]")
+        rprint(f"[dim]Reopen with:  molexp watch --workspace {workspace or '.'} [/dim]")
+    else:
+        verb = "resumed" if resume else "submitted"
+        rprint(f"\n[green]OK[/green] {n} runs {verb}.")
+        if submitted:
+            rprint(f"[dim]Open the monitor with:  molexp watch --workspace {workspace or '.'} [/dim]")
+
+
+@app.command()
+def execute(
+    run_dir: Annotated[
+        Path,
+        typer.Argument(
+            help="Path to the run directory (contains run.json).",
+            exists=True,
+            file_okay=False,
+            dir_okay=True,
+            readable=True,
+            resolve_path=True,
+        ),
+    ],
+) -> None:
+    """Execute a run from its run directory.
+
+    This is the worker entry point used by cluster backends.  The run
+    directory must contain a ``run.json`` with a ``script`` field written
+    by ``molexp run`` at submission time.
+    """
+    import asyncio
+
+    from molexp.config import ProfileConfig
+    from molexp.entry import find_workflow_for_run, load_workspaces
+    from molexp.workspace.run import RunContext
+
+    ctx = RunContext.open(run_dir)
+    run = ctx.run
+
+    script = run.metadata.script
+    if script is None:
+        rprint(
+            "[red]Error:[/red] run.json has no 'script' field. "
+            "This run was not created with a recent version of molexp."
+        )
+        raise typer.Exit(1)
+
+    try:
+        workspaces = load_workspaces(Path(script))
+    except Exception as exc:
+        rprint(f"[red]Error importing {script}:[/red] {exc}")
+        rprint(traceback.format_exc(), end="")
+        raise typer.Exit(1)
+
+    workflow = find_workflow_for_run(workspaces, run)
+    if workflow is None:
+        rprint(
+            f"[red]Error:[/red] No workflow found for experiment "
+            f"'{run.experiment.id}' in project '{run.experiment.project.id}' "
+            f"in {script}."
+        )
+        raise typer.Exit(1)
+
+    profile_config = ProfileConfig(run.metadata.config, name=run.metadata.profile)
+    asyncio.run(workflow.execute(run=run, profile_config=profile_config))
+
+
+# Silence unused-import lint (console is re-exported for other modules).
+_ = console
diff --git a/src/molexp/cli/runs.py b/src/molexp/cli/runs.py
new file mode 100644
index 00000000..8ac0b40e
--- /dev/null
+++ b/src/molexp/cli/runs.py
@@ -0,0 +1,374 @@
+"""``molexp runs ...`` — run-entity management sub-commands."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Annotated, Any, List, Optional
+
+import typer
+from rich.table import Table
+
+from . import app
+from ._common import (
+    _TERMINAL_STATUSES,
+    console,
+    get_workspace,
+    rprint,
+    run_executor_info,
+    status_color,
+)
+
+run_app = typer.Typer(help="Run management commands")
+app.add_typer(run_app, name="runs")
+
+
+@run_app.command("create")
+def run_create(
+    project_id: Annotated[str, typer.Argument(help="Project ID")],
+    experiment_id: Annotated[str, typer.Argument(help="Experiment ID")],
+    params: Annotated[
+        Optional[str],
+        typer.Option("--params", help="Parameters JSON string or file path"),
+    ] = None,
+    path: Annotated[
+        Optional[Path],
+        typer.Option("--path", "-p", help="Workspace path"),
+    ] = None,
+) -> None:
+    """Create a new run."""
+    ws = get_workspace(path)
+
+    parameters: dict = {}
+    if params:
+        params_path = Path(params)
+        if params_path.exists():
+            parameters = json.loads(params_path.read_text())
+        else:
+            try:
+                parameters = json.loads(params)
+            except json.JSONDecodeError:
+                rprint(f"[red]Error:[/red] Invalid JSON in parameters: {params}")
+                raise typer.Exit(1)
+
+    try:
+        project = ws.get_project(project_id)
+        if not project:
+            rprint(f"[red]Error:[/red] Project not found: {project_id}")
+            raise typer.Exit(1)
+
+        experiment = project.get_experiment(experiment_id)
+        if not experiment:
+            rprint(f"[red]Error:[/red] Experiment not found: {experiment_id}")
+            raise typer.Exit(1)
+
+        r = experiment.run(parameters=parameters)
+        rprint(f"[green]OK[/green] Created run: {r.id}")
+        rprint(f"  Project: {project_id}")
+        rprint(f"  Experiment: {experiment_id}")
+        rprint(f"  Status: {r.status}")
+        if parameters:
+            rprint(f"  Parameters: {json.dumps(parameters, indent=2)}")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        rprint(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@run_app.command("list")
+def run_list(
+    project_id: Annotated[str, typer.Argument(help="Project ID")],
+    experiment_id: Annotated[str, typer.Argument(help="Experiment ID")],
+    path: Annotated[
+        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
+    ] = None,
+) -> None:
+    """List all runs in an experiment."""
+    ws = get_workspace(path)
+
+    project = ws.get_project(project_id)
+    if not project:
+        rprint(f"[red]Error:[/red] Project not found: {project_id}")
+        raise typer.Exit(1)
+
+    experiment = project.get_experiment(experiment_id)
+    if not experiment:
+        rprint(f"[red]Error:[/red] Experiment not found: {experiment_id}")
+        raise typer.Exit(1)
+
+    runs = experiment.list_runs()
+
+    if not runs:
+        rprint(f"[yellow]No runs found in {project_id}/{experiment_id}[/yellow]")
+        return
+
+    table = Table(title=f"Runs in {project_id}/{experiment_id}")
+    table.add_column("Run ID", style="cyan")
+    table.add_column("Status", style="green")
+    table.add_column("Profile", style="cyan")
+    table.add_column("Created")
+
+    for r in runs:
+        status = str(r.status).lower()
+        color = status_color(status)
+        profile_display = r.metadata.profile or "—"
+
+        table.add_row(
+            r.id,
+            f"[{color}]{status}[/{color}]",
+            profile_display,
+            r.metadata.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+        )
+
+    console.print(table)
+
+
+@run_app.command("cancel")
+def run_cancel(
+    run_ids: Annotated[
+        Optional[List[str]],
+        typer.Argument(
+            help="Run IDs to cancel. Omit to use --project/--experiment with --all or --status."
+        ),
+    ] = None,
+    project_id: Annotated[
+        Optional[str],
+        typer.Option("--project", "-p", help="Project ID (required in experiment-scope mode)."),
+    ] = None,
+    experiment_id: Annotated[
+        Optional[str],
+        typer.Option("--experiment", "-e", help="Experiment ID (required in experiment-scope mode)."),
+    ] = None,
+    all_runs: Annotated[
+        bool,
+        typer.Option("--all", help="Cancel all non-terminal runs in the experiment."),
+    ] = False,
+    status_filter: Annotated[
+        Optional[str],
+        typer.Option("--status", help="Comma-separated statuses to filter (e.g. 'pending,running')."),
+    ] = None,
+    scheduler: Annotated[
+        str,
+        typer.Option(
+            "--scheduler",
+            help="Fallback molq scheduler backend when run metadata lacks executor info.",
+        ),
+    ] = "slurm",
+    cluster: Annotated[
+        Optional[str],
+        typer.Option("--cluster", help="molq cluster name (default: 'default')."),
+    ] = None,
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip confirmation prompt."),
+    ] = False,
+    path: Annotated[
+        Optional[Path],
+        typer.Option("--path", help="Workspace path."),
+    ] = None,
+) -> None:
+    """Cancel one or more scheduled runs."""
+    ws = get_workspace(path)
+
+    target_runs: list[Any] = []
+
+    if run_ids:
+        for rid in run_ids:
+            found = None
+            for proj in ws.list_projects():
+                for exp in proj.list_experiments():
+                    r = exp.get_run(rid)
+                    if r is not None:
+                        found = r
+                        break
+                if found:
+                    break
+            if found is None:
+                rprint(f"[yellow]Warning:[/yellow] Run {rid!r} not found — skipping.")
+            else:
+                target_runs.append(found)
+    else:
+        if not project_id or not experiment_id:
+            rprint(
+                "[red]Error:[/red] Provide run IDs as arguments, or both "
+                "--project and --experiment options."
+            )
+            raise typer.Exit(1)
+
+        project = ws.get_project(project_id)
+        if not project:
+            rprint(f"[red]Error:[/red] Project not found: {project_id}")
+            raise typer.Exit(1)
+
+        experiment = project.get_experiment(experiment_id)
+        if not experiment:
+            rprint(f"[red]Error:[/red] Experiment not found: {experiment_id}")
+            raise typer.Exit(1)
+
+        candidates = experiment.list_runs()
+
+        if all_runs:
+            target_runs = [r for r in candidates if r.status not in _TERMINAL_STATUSES]
+        elif status_filter:
+            allowed = {s.strip().lower() for s in status_filter.split(",")}
+            target_runs = [r for r in candidates if r.status in allowed]
+        else:
+            rprint(
+                "[red]Error:[/red] Specify --all or --status when using "
+                "--project/--experiment mode."
+            )
+            raise typer.Exit(1)
+
+    if not target_runs:
+        rprint("[yellow]No runs matched the criteria — nothing to cancel.[/yellow]")
+        raise typer.Exit(0)
+
+    already_terminal = [r for r in target_runs if r.status in _TERMINAL_STATUSES]
+    target_runs = [r for r in target_runs if r.status not in _TERMINAL_STATUSES]
+
+    for r in already_terminal:
+        rprint(f"[yellow]Skipping[/yellow] {r.id} — already terminal: {r.status}")
+
+    if not target_runs:
+        rprint("[yellow]All matched runs are already in a terminal state.[/yellow]")
+        raise typer.Exit(0)
+
+    table = Table(title=f"Runs to cancel ({len(target_runs)})")
+    table.add_column("Run ID", style="cyan")
+    table.add_column("Status", style="yellow")
+    table.add_column("Scheduler", style="magenta")
+    table.add_column("molq_job_id", style="dim")
+    table.add_column("scheduler_job_id", style="dim")
+
+    for r in target_runs:
+        executor_info = run_executor_info(r)
+        table.add_row(
+            r.id,
+            r.status,
+            executor_info.get("scheduler") or scheduler,
+            executor_info.get("job_id") or "—",
+            executor_info.get("scheduler_job_id") or "—",
+        )
+
+    console.print(table)
+
+    if not yes:
+        confirm = typer.prompt(f"\nCancel {len(target_runs)} job(s)? [y/N]", default="N")
+        if confirm.strip().lower() not in ("y", "yes"):
+            rprint("[dim]Aborted.[/dim]")
+            raise typer.Exit(0)
+
+    submitor_cache: dict[tuple[str, str], Any] = {}
+    molq_available = True
+    Submitor = None
+    try:
+        from molq import Submitor  # type: ignore[import]
+    except ImportError:
+        molq_available = False
+        rprint(
+            "[yellow]Warning:[/yellow] molq is not installed — will only update "
+            "workspace state without calling the scheduler.\n"
+            "  Install with: [bold]pip install molq[/bold]"
+        )
+
+    cancelled = 0
+    errors = 0
+
+    try:
+        for r in target_runs:
+            executor_info = run_executor_info(r)
+            molq_id = executor_info.get("job_id")
+            scheduler_job_id = executor_info.get("scheduler_job_id")
+            run_scheduler = executor_info.get("scheduler") or scheduler
+            run_cluster = executor_info.get("cluster_name") or cluster or "default"
+
+            if Submitor is not None and molq_available:
+                if molq_id and run_scheduler:
+                    cache_key = (run_scheduler, run_cluster)
+                    submitor = submitor_cache.get(cache_key)
+                    if submitor is None:
+                        submitor = Submitor(cluster_name=run_cluster, scheduler=run_scheduler)
+                        submitor_cache[cache_key] = submitor
+                    try:
+                        submitor.cancel(molq_id)
+                    except Exception as exc:
+                        rprint(
+                            f"  [yellow]Warning:[/yellow] scheduler cancel failed for "
+                            f"{r.id} (molq_job_id={molq_id}, scheduler={run_scheduler}): {exc}"
+                        )
+                        errors += 1
+                elif scheduler_job_id and run_scheduler:
+                    cache_key = (run_scheduler, run_cluster)
+                    submitor = submitor_cache.get(cache_key)
+                    if submitor is None:
+                        submitor = Submitor(cluster_name=run_cluster, scheduler=run_scheduler)
+                        submitor_cache[cache_key] = submitor
+                    try:
+                        submitor._scheduler_impl.cancel(scheduler_job_id)
+                    except Exception as exc:
+                        rprint(
+                            f"  [yellow]Warning:[/yellow] scheduler cancel failed for "
+                            f"{r.id} (scheduler_job_id={scheduler_job_id}, scheduler={run_scheduler}): {exc}"
+                        )
+                        errors += 1
+                else:
+                    rprint(
+                        f"  [yellow]Warning:[/yellow] {r.id} has no molq job metadata — "
+                        "updating workspace state only."
+                    )
+
+            r.cancel()
+            rprint(f"  [green]OK[/green] Cancelled {r.id}")
+            cancelled += 1
+    finally:
+        for submitor in submitor_cache.values():
+            submitor.close()
+
+    rprint(f"\n[green]Done.[/green] {cancelled} run(s) cancelled", end="")
+    if errors:
+        rprint(f", [yellow]{errors} scheduler error(s)[/yellow] (workspace state updated).")
+    else:
+        rprint(".")
+
+
+@run_app.command("info")
+def run_info(
+    project_id: Annotated[str, typer.Argument(help="Project ID")],
+    experiment_id: Annotated[str, typer.Argument(help="Experiment ID")],
+    run_id: Annotated[str, typer.Argument(help="Run ID")],
+    path: Annotated[
+        Optional[Path], typer.Option("--path", "-p", help="Workspace path")
+    ] = None,
+) -> None:
+    """Show run information."""
+    ws = get_workspace(path)
+
+    project = ws.get_project(project_id)
+    if not project:
+        rprint(f"[red]Error:[/red] Project not found: {project_id}")
+        raise typer.Exit(1)
+
+    experiment = project.get_experiment(experiment_id)
+    if not experiment:
+        rprint(f"[red]Error:[/red] Experiment not found: {experiment_id}")
+        raise typer.Exit(1)
+
+    r = experiment.get_run(run_id)
+    if not r:
+        rprint(f"[red]Error:[/red] Run not found: {run_id}")
+        raise typer.Exit(1)
+
+    rprint(f"[bold]Run:[/bold] {r.id}")
+    rprint(f"  Status: {r.status}")
+    rprint(f"  Created: {r.metadata.created_at}")
+    if r.metadata.finished_at:
+        rprint(f"  Finished: {r.metadata.finished_at}")
+    if r.metadata.profile:
+        rprint(f"  Profile: [cyan]{r.metadata.profile}[/cyan]")
+        if r.metadata.config_hash:
+            rprint(f"  Config hash: {r.metadata.config_hash[:12]}…")
+        if r.metadata.config:
+            rprint(f"  Config: {json.dumps(r.metadata.config, indent=2, default=str)}")
+    rprint(f"  Parameters: {json.dumps(r.parameters, indent=2, default=str)}")
diff --git a/src/molexp/cli/serve_cmd.py b/src/molexp/cli/serve_cmd.py
new file mode 100644
index 00000000..99093897
--- /dev/null
+++ b/src/molexp/cli/serve_cmd.py
@@ -0,0 +1,69 @@
+"""``molexp serve`` — start the FastAPI server + bundled UI."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Annotated
+
+import typer
+import uvicorn
+
+from . import app
+from ._common import rprint
+
+
+@app.command()
+def serve(
+    workspace: Annotated[
+        Path,
+        typer.Option(
+            "--workspace",
+            "-w",
+            help="Workspace root (default: current directory).",
+            exists=True,
+            file_okay=False,
+            dir_okay=True,
+            writable=True,
+        ),
+    ] = Path.cwd(),
+    port: Annotated[
+        int,
+        typer.Option("--port", "-p", help="Server port"),
+    ] = 8000,
+    host: Annotated[
+        str,
+        typer.Option("--host", "-h", help="Server host"),
+    ] = "localhost",
+) -> None:
+    """Start the MolExp server (API + bundled web UI)."""
+    resolved = Path(workspace).resolve()
+    if not (resolved / "workspace.json").exists():
+        candidate = resolved / "workspace"
+        if (candidate / "workspace.json").exists():
+            resolved = candidate
+            rprint(f"[dim]Auto-detected workspace at {resolved}[/dim]")
+        else:
+            rprint(
+                f"[yellow]Warning:[/yellow] No workspace.json found in {resolved}. "
+                "Run [bold]molexp init[/bold] or use [bold]--workspace[/bold]."
+            )
+
+    os.chdir(resolved)
+    rprint(f"[bold]Serving Workspace:[/bold] {workspace}")
+
+    from molexp.server.app import _find_bundled_webapp, create_app
+
+    webapp = _find_bundled_webapp()
+    if webapp is None:
+        rprint(f"[cyan]->[/cyan] API at http://{host}:{port}/api  (no bundled UI)")
+        rprint(
+            "[dim]  Build a wheel to include the frontend, "
+            "or run the frontend dev server separately:[/dim]"
+        )
+        rprint(f"[dim]  cd ui && npm run dev -- --api-port={port}[/dim]")
+    else:
+        rprint(f"[cyan]->[/cyan] http://{host}:{port}")
+
+    application = create_app()
+    uvicorn.run(application, host=host, port=port, log_level="info")
diff --git a/src/molexp/cli/watch_cmd.py b/src/molexp/cli/watch_cmd.py
new file mode 100644
index 00000000..3eccfdfe
--- /dev/null
+++ b/src/molexp/cli/watch_cmd.py
@@ -0,0 +1,85 @@
+"""``molexp watch`` — reopen the interactive run monitor."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Annotated, Any, Optional
+
+import typer
+
+from . import app
+from ._common import rprint
+
+
+def _logical_cwd() -> Path:
+    """Return cwd preserving symlinks (uses $PWD if it points to cwd)."""
+    pwd = os.environ.get("PWD")
+    if pwd and os.path.samefile(pwd, os.getcwd()):
+        return Path(pwd)
+    return Path(os.getcwd())
+
+
+@app.command()
+def watch(
+    workspace: Annotated[
+        Optional[Path],
+        typer.Option("--workspace", "-w", help="Workspace root (default: current directory)."),
+    ] = None,
+    project: Annotated[
+        Optional[str],
+        typer.Option("--project", "-p", help="Filter by project name or ID."),
+    ] = None,
+    experiment: Annotated[
+        Optional[str],
+        typer.Option("--experiment", "-e", help="Filter by experiment name or ID."),
+    ] = None,
+    refresh: Annotated[
+        float,
+        typer.Option("--refresh", "-r", help="Refresh interval in seconds."),
+    ] = 2.0,
+) -> None:
+    """Reopen the full-screen run monitor for an existing workspace."""
+    if workspace is None:
+        ws_root = _logical_cwd()
+    elif workspace.is_absolute():
+        ws_root = workspace
+    else:
+        ws_root = _logical_cwd() / workspace
+
+    try:
+        from molexp.workspace import Workspace as _Workspace
+        ws = _Workspace.load(ws_root)
+    except FileNotFoundError:
+        rprint(f"[red]Error:[/red] No workspace found at {ws_root}")
+        rprint("  Run [bold]molexp init[/bold] to create one, or pass [bold]--workspace[/bold].")
+        raise typer.Exit(1)
+
+    runs: list[Any] = []
+    for proj in ws.list_projects():
+        if project and proj.id != project and proj.name != project:
+            continue
+        for exp in proj.list_experiments():
+            if experiment and exp.id != experiment and exp.name != experiment:
+                continue
+            runs.extend(exp.list_runs())
+
+    if not runs:
+        rprint("[yellow]No runs found[/yellow] — check --project / --experiment filters.")
+        raise typer.Exit(0)
+
+    try:
+        from molexp.monitor import RunMonitor
+    except ImportError:
+        rprint("[red]Error:[/red] molq is not installed. Install it to use the monitor.")
+        raise typer.Exit(1)
+
+    title = ws.name
+    if experiment:
+        title = f"{ws.name} / {experiment}"
+    elif project:
+        title = f"{ws.name} / {project}"
+
+    rprint(f"[dim]Watching {len(runs)} runs. Press q to close.[/dim]")
+    RunMonitor(title=title, refresh_interval=refresh).watch(runs)
+    rprint("\n[dim]Monitor closed. Runs are still executing (if any).[/dim]")
diff --git a/src/molexp/cli/workspace_cmd.py b/src/molexp/cli/workspace_cmd.py
new file mode 100644
index 00000000..8bcdb62d
--- /dev/null
+++ b/src/molexp/cli/workspace_cmd.py
@@ -0,0 +1,87 @@
+"""``molexp init`` / ``molexp info`` — workspace top-level commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from molexp.workspace import Workspace
+
+from . import app
+from ._common import get_workspace, rprint, status_color
+
+
+@app.command()
+def init(
+    path: Annotated[
+        Optional[Path],
+        typer.Argument(help="Workspace path (default: current directory)"),
+    ] = None,
+) -> None:
+    """Initialize a new workspace."""
+    workspace_path = path or Path.cwd()
+    ws = Workspace.from_path(workspace_path)
+
+    rprint(f"[green]OK[/green] Initialized workspace at: {ws.root}")
+    rprint(f"  - Projects directory: {ws.root / 'projects'}")
+    rprint(f"  - Assets directory: {ws.root / 'assets'}")
+
+
+@app.command()
+def info(
+    path: Annotated[
+        Optional[Path],
+        typer.Option("--path", "-p", help="Workspace path"),
+    ] = None,
+) -> None:
+    """Show workspace information."""
+    ws = get_workspace(path)
+
+    projects = ws.list_projects()
+
+    total_experiments = 0
+    total_runs = 0
+    run_status_counts: dict[str, int] = {
+        "pending": 0,
+        "running": 0,
+        "succeeded": 0,
+        "failed": 0,
+        "cancelled": 0,
+    }
+    profile_counts: dict[str, int] = {}
+
+    for project in projects:
+        experiments = project.list_experiments()
+        total_experiments += len(experiments)
+
+        for experiment in experiments:
+            runs = experiment.list_runs()
+            total_runs += len(runs)
+
+            for r in runs:
+                status = str(r.status).lower()
+                if status in run_status_counts:
+                    run_status_counts[status] += 1
+                pname = r.metadata.profile
+                if pname:
+                    profile_counts[pname] = profile_counts.get(pname, 0) + 1
+
+    rprint(f"[bold]Workspace:[/bold] {ws.root}")
+    rprint("\n[bold]Statistics:[/bold]")
+    rprint(f"  Projects: {len(projects)}")
+    rprint(f"  Experiments: {total_experiments}")
+    rprint(f"  Runs: {total_runs}")
+
+    if total_runs > 0:
+        rprint("\n[bold]Run Status:[/bold]")
+        for status, count in run_status_counts.items():
+            if count > 0:
+                color = status_color(status)
+                rprint(f"  [{color}]{status.capitalize()}[/{color}]: {count}")
+
+    if profile_counts:
+        rprint("\n[bold]Profiles:[/bold]")
+        for pname, count in sorted(profile_counts.items()):
+            rprint(f"  [cyan]{pname}[/cyan]: {count}")
diff --git a/src/molexp/config.py b/src/molexp/config.py
deleted file mode 100644
index 40c88595..00000000
--- a/src/molexp/config.py
+++ /dev/null
@@ -1,28 +0,0 @@
-"""Unified configuration for molexp."""
-
-from __future__ import annotations
-
-from pydantic import BaseModel, Field
-
-
-class MolexpConfig(BaseModel):
-    """Runtime configuration settings."""
-
-    plugin_fail_fast: bool = Field(
-        True, description="Fail-fast on plugin load errors"
-    )
-
-
-_CONFIG = MolexpConfig()
-
-
-def get_config() -> MolexpConfig:
-    """Return the active configuration."""
-    return _CONFIG
-
-
-def set_config(**kwargs) -> MolexpConfig:
-    """Update configuration values."""
-    global _CONFIG
-    _CONFIG = _CONFIG.model_copy(update=kwargs)
-    return _CONFIG
diff --git a/src/molexp/config/__init__.py b/src/molexp/config/__init__.py
new file mode 100644
index 00000000..c73c24f3
--- /dev/null
+++ b/src/molexp/config/__init__.py
@@ -0,0 +1,28 @@
+"""molexp configuration: molcfg.yaml loading + named profiles.
+
+Public surface:
+
+- :class:`ProfileConfig` — immutable, mapping-like per-profile config with
+  a normalized ``name`` and deterministic :meth:`content_hash`.
+- :func:`load_molcfg` — parse a ``molcfg.yaml`` / ``.json`` file into a
+  :class:`MolCfg`.
+- :class:`MolCfg` — top-level schema (``defaults`` + ``profiles``) with
+  :meth:`resolve` to materialize a :class:`ProfileConfig` for a given
+  profile name.
+
+Framework contract: molexp only *carries* a profile (persist its name,
+inject it into ``ctx.config``). It does not interpret profile contents.
+Any semantics (dataset choice, whether to skip heavy compute, etc.) are
+user-defined fields that the user's task code reads explicitly.
+"""
+
+from molexp.config.models import MolCfg, ProfileConfig, normalize_profile_name
+from molexp.config.loader import DEFAULT_CONFIG_FILENAMES, load_molcfg
+
+__all__ = [
+    "MolCfg",
+    "ProfileConfig",
+    "load_molcfg",
+    "normalize_profile_name",
+    "DEFAULT_CONFIG_FILENAMES",
+]
diff --git a/src/molexp/config/loader.py b/src/molexp/config/loader.py
new file mode 100644
index 00000000..b90402db
--- /dev/null
+++ b/src/molexp/config/loader.py
@@ -0,0 +1,50 @@
+"""File loading for molexp configuration (YAML / JSON)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from molcfg import JsonFileSource, YamlFileSource
+
+from molexp.config.models import MolCfg
+
+DEFAULT_CONFIG_FILENAMES: tuple[str, ...] = ("molcfg.yaml", "molcfg.yml", "molcfg.json")
+
+
+def load_molcfg(path: str | Path) -> MolCfg:
+    """Load a :class:`MolCfg` from a YAML or JSON file.
+
+    The format is decided by file suffix. Raises
+    :class:`FileNotFoundError` if *path* does not exist and
+    :class:`ValueError` for unsupported suffixes.
+    """
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(f"Config file not found: {p}")
+
+    suffix = p.suffix.lower()
+    if suffix in (".yaml", ".yml"):
+        raw = YamlFileSource(p).load()
+    elif suffix == ".json":
+        raw = JsonFileSource(p).load()
+    else:
+        raise ValueError(
+            f"Unsupported config suffix {suffix!r}; expected one of "
+            ".yaml, .yml, .json"
+        )
+
+    return MolCfg.model_validate(raw)
+
+
+def find_default_config(start: Path | None = None) -> Path | None:
+    """Search *start* (default CWD) for a default-named molcfg file.
+
+    Returns the first match in :data:`DEFAULT_CONFIG_FILENAMES` order,
+    or ``None`` if none exists.
+    """
+    base = Path(start) if start is not None else Path.cwd()
+    for name in DEFAULT_CONFIG_FILENAMES:
+        candidate = base / name
+        if candidate.exists():
+            return candidate
+    return None
diff --git a/src/molexp/config/models.py b/src/molexp/config/models.py
new file mode 100644
index 00000000..0c752b2e
--- /dev/null
+++ b/src/molexp/config/models.py
@@ -0,0 +1,170 @@
+"""Schema and value objects for molexp configuration / profiles."""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+from collections.abc import Iterator, Mapping
+from typing import Any
+
+from molcfg import DictSource, ProfileLoader
+from pydantic import BaseModel, Field, field_validator
+
+
+def normalize_profile_name(name: str) -> str:
+    """Normalize profile name: strip, lowercase-safe, replace ``-`` with ``_``.
+
+    Example: ``"Dry-Run"`` → ``"Dry_Run"``.  The framework does not
+    lowercase (preserve user casing), it only unifies the dash/underscore
+    split so CLI (``--profile dry-run``) and YAML keys (``dry_run:``)
+    agree.
+    """
+    return name.strip().replace("-", "_")
+
+
+class ProfileConfig(Mapping[str, Any]):
+    """Immutable merged configuration for one profile.
+
+    Behaves like a read-only mapping of user-defined fields.  Carries:
+
+    - :attr:`name`: normalized profile name, or ``None`` when no profile
+      was selected (``defaults`` only).
+    - :meth:`content_hash`: deterministic hex digest of the merged data,
+      suitable for ``RunMetadata.config_hash``.
+
+    The framework adds no semantic keys; every entry comes straight from
+    the user's YAML / JSON.
+    """
+
+    __slots__ = ("_name", "_data")
+
+    def __init__(self, data: Mapping[str, Any], *, name: str | None) -> None:
+        self._name = normalize_profile_name(name) if name is not None else None
+        # deep-copy so callers cannot mutate internal state post-construction
+        self._data: dict[str, Any] = copy.deepcopy(dict(data))
+
+    @property
+    def name(self) -> str | None:
+        return self._name
+
+    def __getitem__(self, key: str) -> Any:
+        return self._data[key]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._data)
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __contains__(self, key: object) -> bool:  # type: ignore[override]
+        return key in self._data
+
+    def __repr__(self) -> str:
+        return f"ProfileConfig(name={self._name!r}, keys={list(self._data)!r})"
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return a fresh mutable copy of the merged data."""
+        return copy.deepcopy(self._data)
+
+    def content_hash(self) -> str:
+        """Deterministic sha256 hex digest of the merged config.
+
+        Only the data payload is hashed — the profile name is not
+        included, because two profiles that resolve to identical data
+        should produce the same hash (useful for cache keys).
+        """
+        payload = json.dumps(self._data, sort_keys=True, default=str)
+        return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+class MolCfg(BaseModel):
+    """Top-level molcfg.yaml schema.
+
+    ``defaults`` is merged first, then the selected profile's data is
+    merged on top (via molcfg's deep-merge strategy).  Profiles may set
+    ``extends: <base-profile-name>`` to inherit from another profile;
+    the chain ultimately roots at ``defaults``.
+    """
+
+    version: int = 1
+    defaults: dict[str, Any] = Field(default_factory=dict)
+    profiles: dict[str, dict[str, Any]] = Field(default_factory=dict)
+
+    model_config = {"frozen": True}
+
+    @field_validator("profiles", mode="before")
+    @classmethod
+    def _normalize_profile_keys(cls, value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        return {normalize_profile_name(str(k)): v for k, v in value.items()}
+
+    def list_profiles(self) -> list[str]:
+        """Return the normalized profile names declared in the file."""
+        return list(self.profiles)
+
+    def resolve(self, name: str | None) -> ProfileConfig:
+        """Materialize the merged :class:`ProfileConfig` for *name*.
+
+        Passing ``None`` returns the ``defaults``-only config.  Raises
+        :class:`KeyError` on unknown profile names.
+        """
+        if name is None:
+            return ProfileConfig(self.defaults, name=None)
+
+        norm = normalize_profile_name(name)
+        if norm not in self.profiles:
+            raise KeyError(
+                f"Unknown profile: {name!r} (normalized: {norm!r}). "
+                f"Available: {sorted(self.profiles)}"
+            )
+
+        # Resolve extends chain into a list of profile dicts, from root
+        # ancestor to target.  Detect cycles.
+        chain = self._resolve_chain(norm)
+        profile_sources = {
+            pname: DictSource(self._strip_extends(self.profiles[pname]), name=pname)
+            for pname in chain
+        }
+        loader = ProfileLoader(
+            base_sources=[DictSource(self.defaults, name="defaults")],
+            profiles=profile_sources,
+        )
+        # Apply profiles in order by successively merging; ProfileLoader
+        # only applies one profile overlay per load, so we chain manually.
+        merged: dict[str, Any] = dict(self.defaults)
+        from molcfg import MergeStrategy, merge
+
+        for pname in chain:
+            overlay = self._strip_extends(self.profiles[pname])
+            merged = merge(merged, overlay, MergeStrategy.DEEP_MERGE)
+
+        return ProfileConfig(merged, name=norm)
+
+    def _resolve_chain(self, target: str) -> list[str]:
+        """Walk ``extends`` links; return ancestor→target profile names."""
+        chain: list[str] = []
+        seen: set[str] = set()
+        current: str | None = target
+        while current is not None:
+            if current in seen:
+                raise ValueError(
+                    f"Circular profile inheritance detected at {current!r}"
+                )
+            if current not in self.profiles:
+                raise KeyError(f"Profile {current!r} referenced by extends not found")
+            seen.add(current)
+            chain.append(current)
+            extends = self.profiles[current].get("extends")
+            if extends is None or extends == "defaults":
+                current = None
+            else:
+                current = normalize_profile_name(str(extends))
+        # chain is target-first; reverse so root ancestor is applied first
+        chain.reverse()
+        return chain
+
+    @staticmethod
+    def _strip_extends(profile: dict[str, Any]) -> dict[str, Any]:
+        return {k: v for k, v in profile.items() if k != "extends"}
diff --git a/src/molexp/entry.py b/src/molexp/entry.py
new file mode 100644
index 00000000..1ad2a25e
--- /dev/null
+++ b/src/molexp/entry.py
@@ -0,0 +1,111 @@
+"""Entry point registry for CLI discovery.
+
+User scripts call ``me.entry(workspace)`` at module level to register
+a workspace for CLI execution.  The CLI calls ``load_workspaces(script)``
+to import the script and retrieve all registered workspaces.
+
+No source scanning, no magic attribute discovery — explicit registration.
+
+Example (user script)::
+
+    import molexp as me
+
+    ws = me.Workspace("./lab")
+    project = ws.project("my-project")
+    exp = project.experiment("baseline", params={"lr": 1e-3}, n_replicas=3)
+    exp.set_workflow(train)
+    me.entry(ws)
+
+Example (CLI internal)::
+
+    from molexp.entry import load_workspaces
+    workspaces = load_workspaces(Path("train.py"))
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from molexp.workspace.workspace import Workspace
+
+_registry: list["Workspace"] = []
+
+
+def entry(workspace: "Workspace") -> None:
+    """Register a workspace as a CLI entry point.
+
+    When a script is imported by ``molexp run``, this call populates
+    the global registry.  When the script is run directly
+    (``python script.py``), nobody reads the registry — it is
+    effectively a no-op.
+
+    Args:
+        workspace: A :class:`~molexp.Workspace` to register.
+    """
+    _registry.append(workspace)
+
+
+def load_workspaces(script: Path) -> list["Workspace"]:
+    """Import a user script and return all registered workspaces.
+
+    Args:
+        script: Path to the Python script containing ``me.entry()`` calls.
+
+    Returns:
+        List of registered :class:`~molexp.Workspace` instances.
+
+    Raises:
+        RuntimeError: If the script cannot be loaded.
+    """
+    _registry.clear()
+    _import_script(script)
+    return list(_registry)
+
+
+def find_workflow_for_run(workspaces: list["Workspace"], run: Any) -> Any | None:
+    """Return the workflow object matching *run*'s project and experiment IDs.
+
+    Searches all registered workspaces returned by :func:`load_workspaces` for
+    an experiment whose ``(project.id, experiment.id)`` pair matches that of
+    *run*.  Returns ``None`` if no match is found.
+
+    Args:
+        workspaces: List of :class:`~molexp.Workspace` instances (from
+            :func:`load_workspaces`).
+        run: A workspace ``Run`` whose ``experiment.project.id`` and
+            ``experiment.id`` are used as lookup keys.
+
+    Returns:
+        The matching :class:`~molexp.workflow.WorkflowSpec`, or ``None``.
+    """
+    target_project_id = run.experiment.project.id
+    target_exp_id = run.experiment.id
+
+    for ws in workspaces:
+        for proj in ws.list_projects():
+            if proj.id != target_project_id:
+                continue
+            for exp in proj.list_experiments():
+                if exp.id == target_exp_id and exp.workflow is not None:
+                    return exp.workflow
+    return None
+
+
+def clear_registry() -> None:
+    """Clear the registry (for tests)."""
+    _registry.clear()
+
+
+def _import_script(script: Path) -> None:
+    """Dynamically import a user script."""
+    spec = importlib.util.spec_from_file_location("_molexp_script", script)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Cannot load script: {script}")
+    module = importlib.util.module_from_spec(spec)
+    try:
+        spec.loader.exec_module(module)  # type: ignore[union-attr]
+    except SystemExit:
+        pass  # silence __main__ guards
diff --git a/src/molexp/monitor.py b/src/molexp/monitor.py
new file mode 100644
index 00000000..d6574f62
--- /dev/null
+++ b/src/molexp/monitor.py
@@ -0,0 +1,182 @@
+"""RunMonitor: lifecycle controller for the full-screen run dashboard.
+
+molexp owns when the dashboard opens, closes, and can be reopened.
+molq owns the dashboard renderer (:class:`~molq.dashboard.RunDashboard`).
+
+Usage (from CLI or programmatic code)::
+
+    from molexp.monitor import RunMonitor
+
+    monitor = RunMonitor(title="my-sweep")
+    monitor.watch(runs)           # blocks until user presses 'q'
+    # jobs keep running after this returns
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from molexp.plugins.submit_molq.metadata import normalize_executor_info
+
+if TYPE_CHECKING:
+    from molexp.workspace.run import Run
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+
+def _elapsed(created_at: str | None, finished_at: str | None = None) -> str | None:
+    """Compute human-readable elapsed time from ISO timestamps."""
+    if not created_at:
+        return None
+    try:
+        start = datetime.fromisoformat(created_at)
+        end   = datetime.fromisoformat(finished_at) if finished_at else datetime.now()
+        secs  = max(0, int((end - start).total_seconds()))
+        if secs < 60:
+            return f"{secs}s"
+        m, s = divmod(secs, 60)
+        if m < 60:
+            return f"{m}m {s:02d}s"
+        h, m = divmod(m, 60)
+        return f"{h}h {m:02d}m"
+    except Exception:
+        return None
+
+
+def _read_run_json(run_dir: Path) -> dict[str, Any]:
+    """Load run.json without constructing a Run object."""
+    p = run_dir / "run.json"
+    if not p.exists():
+        return {}
+    try:
+        with p.open() as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def _overall_status(running: int, pending: int, failed: int, done: int) -> str:
+    if running > 0:
+        return "running"
+    if pending > 0:
+        return "pending"
+    if failed > 0 and done == 0:
+        return "failed"
+    if failed > 0:
+        return "mixed"
+    return "done"
+
+
+# ── RunMonitor ────────────────────────────────────────────────────────────────
+
+
+class RunMonitor:
+    """Lifecycle controller for the full-screen run dashboard.
+
+    Owns when the dashboard is opened and closed.  Delegates all rendering
+    to :class:`~molq.dashboard.RunDashboard` from the molq package.
+
+    Status is refreshed by re-reading each run's ``run.json`` file on every
+    tick, which works for both local and remote (cluster) runs without any
+    additional IPC.
+
+    Args:
+        title: Display title shown in the monitor header.
+        refresh_interval: Seconds between automatic data refreshes.
+    """
+
+    def __init__(
+        self,
+        title: str = "molexp",
+        *,
+        refresh_interval: float = 2.0,
+    ) -> None:
+        self._title = title
+        self._refresh_interval = refresh_interval
+
+    def watch(self, runs: list[Run]) -> None:
+        """Open the full-screen dashboard and block until the user presses ``q``.
+
+        Closing the dashboard does **not** cancel any running jobs — it only
+        closes the viewer.  The caller is responsible for any post-close
+        messaging (e.g. "reopen with molexp watch …").
+
+        Args:
+            runs: Run objects to monitor.  Paths are snapshot at call time;
+                  status is polled from disk on every refresh.
+        """
+        from molq.dashboard import DashboardState, JobRow, RunDashboard
+
+        # Snapshot (id, run_dir) pairs once — paths are stable
+        run_entries: list[tuple[str, Path]] = [
+            (r.id, r.run_dir) for r in runs
+        ]
+
+        def _build_state() -> DashboardState:
+            rows: list[JobRow] = []
+            running = pending = done = failed = 0
+
+            for run_id, run_dir in run_entries:
+                data   = _read_run_json(run_dir)
+                status = data.get("status", "pending")
+
+                elapsed = _elapsed(
+                    # created_at is the best proxy we have for start time
+                    data.get("created_at"),
+                    data.get("finished_at"),
+                )
+
+                executor_info = normalize_executor_info(
+                    data.get("executor_info"),
+                    data.get("labels"),
+                )
+                sched_id = executor_info.get("scheduler_job_id")
+
+                error_msg: str | None = None
+                if isinstance(data.get("error"), dict):
+                    error_msg = data["error"].get("message")
+
+                profile_name = data.get("profile")
+                extras: tuple[tuple[str, str], ...] = (
+                    (("profile", profile_name),) if profile_name else ()
+                )
+
+                rows.append(JobRow(
+                    state=status,
+                    run_id=run_id,
+                    cluster=executor_info.get("cluster_name"),
+                    scheduler_id=sched_id,
+                    elapsed=elapsed,
+                    message=error_msg,
+                    extras=extras,
+                ))
+
+                s = status.lower()
+                if s == "running":
+                    running += 1
+                elif s == "pending":
+                    pending += 1
+                elif s in ("succeeded", "done"):
+                    done += 1
+                elif s in ("failed", "cancelled"):
+                    failed += 1
+                else:
+                    pending += 1  # unknown → treat as pending
+
+            return DashboardState(
+                title=self._title,
+                overall_status=_overall_status(running, pending, failed, done),
+                total=len(run_entries),
+                running=running,
+                pending=pending,
+                done=done,
+                failed=failed,
+                updated_at=datetime.now().strftime("%H:%M:%S"),
+                jobs=tuple(rows),
+            )
+
+        RunDashboard().watch(_build_state, refresh_interval=self._refresh_interval)
diff --git a/src/molexp/param/__init__.py b/src/molexp/param/__init__.py
deleted file mode 100644
index b1abfcdf..00000000
--- a/src/molexp/param/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""Parameter space definitions for hyperparameter search."""
-
-from .base import ParamSpace
-from .grid import GridSpace
-from .uniform import UniformSpace
-
-__all__ = [
-    "ParamSpace",
-    "GridSpace",
-    "UniformSpace",
-]
-
diff --git a/src/molexp/param/base.py b/src/molexp/param/base.py
deleted file mode 100644
index 7ebfd46f..00000000
--- a/src/molexp/param/base.py
+++ /dev/null
@@ -1,48 +0,0 @@
-"""Base classes for parameter spaces."""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from collections.abc import Generator
-from typing import Any
-
-# Type alias for parameter dictionaries
-Params = dict[str, Any]
-
-
-class ParamSpace(ABC):
-    """Abstract base class for parameter spaces.
-    
-    A parameter space defines how to generate parameter combinations
-    for hyperparameter search. Subclasses implement different search
-    strategies (grid search, random search, etc.).
-    """
-    
-    @abstractmethod
-    def __iter__(self) -> Generator[Params, None, None]:
-        """Generate parameter combinations.
-        
-        Yields:
-            Parameter dictionaries, each representing one combination
-        """
-        ...
-    
-    @abstractmethod
-    def __len__(self) -> int:
-        """Return the total number of parameter combinations.
-        
-        Returns:
-            Number of combinations (may be infinite for some spaces)
-        """
-        ...
-    
-    def count(self) -> int:
-        """Count the number of parameter combinations.
-        
-        Returns:
-            Number of combinations
-        """
-        return len(self)
-
-
-
diff --git a/src/molexp/param/grid.py b/src/molexp/param/grid.py
deleted file mode 100644
index 7e62a2a6..00000000
--- a/src/molexp/param/grid.py
+++ /dev/null
@@ -1,70 +0,0 @@
-"""Grid search parameter space."""
-
-from __future__ import annotations
-
-from collections.abc import Generator
-from itertools import product
-from typing import Any
-
-from .base import ParamSpace, Params
-
-
-class GridSpace(ParamSpace):
-    """Grid search parameter space.
-    
-    Generates all combinations of parameter values using Cartesian product.
-    This is equivalent to nested loops over all parameter values.
-    
-    Example:
-        >>> space = GridSpace({
-        ...     "d_model": [128, 256],
-        ...     "nhead": [4, 8],
-        ...     "lr": [1e-4, 5e-4],
-        ... })
-        >>> for params in space:
-        ...     print(params)
-        {'d_model': 128, 'nhead': 4, 'lr': 0.0001}
-        {'d_model': 128, 'nhead': 4, 'lr': 0.0005}
-        {'d_model': 128, 'nhead': 8, 'lr': 0.0001}
-        ...
-    """
-    
-    def __init__(self, param_grid: dict[str, list[Any]]) -> None:
-        """Initialize grid search space.
-        
-        Args:
-            param_grid: Dictionary mapping parameter names to lists of values.
-                       Each list defines the possible values for that parameter.
-        """
-        self.param_grid = param_grid
-        self._param_names = list(param_grid.keys())
-        self._param_values = list(param_grid.values())
-        
-        # Compute total number of combinations
-        self._total = 1
-        for values in self._param_values:
-            self._total *= len(values)
-    
-    def __iter__(self) -> Generator[Params, None, None]:
-        """Generate all parameter combinations.
-        
-        Yields:
-            Parameter dictionaries, one for each combination
-        """
-        for combination in product(*self._param_values):
-            yield dict(zip(self._param_names, combination))
-    
-    def __len__(self) -> int:
-        """Return total number of combinations.
-        
-        Returns:
-            Number of parameter combinations
-        """
-        return self._total
-    
-    def __repr__(self) -> str:
-        """String representation."""
-        return f"GridSpace({len(self)} combinations)"
-
-
-
diff --git a/src/molexp/param/uniform.py b/src/molexp/param/uniform.py
deleted file mode 100644
index 7b3b612a..00000000
--- a/src/molexp/param/uniform.py
+++ /dev/null
@@ -1,85 +0,0 @@
-"""Uniform distribution parameter space."""
-
-from __future__ import annotations
-
-import random
-from collections.abc import Generator
-from typing import Any
-
-from .base import ParamSpace, Params
-
-
-class UniformSpace(ParamSpace):
-    """Uniform distribution parameter space.
-    
-    Generates random parameter combinations by uniformly sampling from
-    discrete value lists for each parameter.
-    
-    Example:
-        >>> space = UniformSpace({
-        ...     "d_model": [128, 256, 512],
-        ...     "lr": [1e-4, 5e-4, 1e-3],
-        ... }, n_samples=100, seed=42)
-        >>> for params in space:
-        ...     print(params)
-        {'d_model': 256, 'lr': 0.0005}
-        ...
-    """
-    
-    def __init__(
-        self,
-        param_values: dict[str, list[Any]],
-        n_samples: int,
-        seed: int | None = None,
-    ) -> None:
-        """Initialize uniform search space.
-        
-        Args:
-            param_values: Dictionary mapping parameter names to lists of possible values.
-                         Each value in the list has equal probability of being sampled.
-            n_samples: Number of random samples to generate
-            seed: Random seed for reproducibility
-        """
-        self.param_values = param_values
-        self.n_samples = n_samples
-        self.seed = seed
-        
-        if seed is not None:
-            random.seed(seed)
-    
-    def __iter__(self) -> Generator[Params, None, None]:
-        """Generate random parameter combinations.
-        
-        Yields:
-            Parameter dictionaries, one for each random sample
-        """
-        if self.seed is not None:
-            random.seed(self.seed)
-        
-        for _ in range(self.n_samples):
-            params: Params = {}
-            for name, values in self.param_values.items():
-                if not isinstance(values, list):
-                    raise ValueError(
-                        f"Parameter '{name}' must have a list of values, "
-                        f"got {type(values)}"
-                    )
-                if len(values) == 0:
-                    raise ValueError(f"Parameter '{name}' must have at least one value")
-                params[name] = random.choice(values)
-            yield params
-    
-    def __len__(self) -> int:
-        """Return number of samples.
-        
-        Returns:
-            Number of random samples
-        """
-        return self.n_samples
-    
-    def __repr__(self) -> str:
-        """String representation."""
-        return f"UniformSpace({self.n_samples} samples, seed={self.seed})"
-
-
-
diff --git a/src/molexp/plugins/__init__.py b/src/molexp/plugins/__init__.py
new file mode 100644
index 00000000..7523aa8d
--- /dev/null
+++ b/src/molexp/plugins/__init__.py
@@ -0,0 +1,158 @@
+"""Plugin registry for optional molexp capabilities.
+
+Core molexp (workspace + local workflow) has zero optional dependencies.
+Heavy backends — AI agent, etc. — are loaded on demand through this
+registry so that ``import molexp`` never fails due to a missing package.
+
+Plugin naming convention: ``{category}_{implementation}``
+
+- ``submit_molq``  — Job submission via molq schedulers
+- ``agent_pydanticai`` — AI agent via PydanticAI
+
+Usage::
+
+    from molexp.plugins import registry, Capability
+
+    if registry.is_available(Capability.AGENT):
+        service = registry.get(Capability.AGENT)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+from molexp.plugins.submit_molq.metadata import supported_schedulers
+
+
+class Capability(str, Enum):
+    """Extension points that plugins can provide."""
+
+    AGENT = "agent"
+
+
+class CapabilityNotAvailable(RuntimeError):
+    """Raised when a requested capability is not installed / registered."""
+
+    def __init__(self, cap: Capability, hint: str = "") -> None:
+        msg = f"Capability '{cap.value}' is not available."
+        if hint:
+            msg += f" {hint}"
+        super().__init__(msg)
+        self.capability = cap
+
+
+@dataclass(frozen=True)
+class UiPluginDescriptor:
+    """Descriptor for frontend-facing plugin manifests."""
+
+    id: str
+    title: str
+    description: str = ""
+    ui_module: str | None = None
+    capabilities: tuple[str, ...] = ()
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+# ── Lazy loaders ────────────────────────────────────────────────────────────
+# Each function attempts the import and returns the entry-point object,
+# or raises ImportError if the backing package is missing.
+
+_INSTALL_HINTS: dict[Capability, str] = {
+    Capability.AGENT: "Install with: pip install molexp[agent]",
+}
+
+
+def _load_agent() -> Any:
+    from molexp.plugins.agent_pydanticai import get_agent_plugin  # type: ignore[import-not-found]
+    return get_agent_plugin()
+
+
+_LOADERS: dict[Capability, Any] = {
+    Capability.AGENT: _load_agent,
+}
+
+
+# ── Registry singleton ─────────────────────────────────────────────────────
+
+
+class PluginRegistry:
+    """Discovers and caches optional capabilities at runtime."""
+
+    def __init__(self) -> None:
+        self._cache: dict[Capability, Any] = {}
+        self._unavailable: set[Capability] = set()
+
+    def is_available(self, cap: Capability) -> bool:
+        """Check whether *cap* can be loaded (dependency installed)."""
+        if cap in self._cache:
+            return True
+        if cap in self._unavailable:
+            return False
+        try:
+            self._cache[cap] = _LOADERS[cap]()
+            return True
+        except (ImportError, KeyError):
+            self._unavailable.add(cap)
+            return False
+
+    def get(self, cap: Capability) -> Any:
+        """Return the loaded plugin for *cap*, or raise."""
+        if cap in self._cache:
+            return self._cache[cap]
+        if self.is_available(cap):
+            return self._cache[cap]
+        raise CapabilityNotAvailable(
+            cap, _INSTALL_HINTS.get(cap, "")
+        )
+
+    def available_capabilities(self) -> list[Capability]:
+        """Return all capabilities whose backing packages are installed."""
+        return [c for c in Capability if self.is_available(c)]
+
+    def reset(self) -> None:
+        """Clear caches (useful in tests)."""
+        self._cache.clear()
+        self._unavailable.clear()
+
+
+registry = PluginRegistry()
+
+
+def discover_ui_plugins() -> list[UiPluginDescriptor]:
+    """Return frontend plugin manifests for all available UI integrations."""
+    plugins = [
+        UiPluginDescriptor(
+            id="core",
+            title="Core Workspace UI",
+            description="Built-in Molexp workspace renderers and previews.",
+            ui_module="core",
+            capabilities=("workspace", "renderers", "file_previews"),
+        )
+    ]
+
+    schedulers = supported_schedulers()
+    if schedulers:
+        plugins.append(
+            UiPluginDescriptor(
+                id="molq",
+                title="Molq",
+                description="Scheduler-aware run viewers and monitor surfaces for molq-backed runs.",
+                ui_module="molq",
+                capabilities=("submit", "monitor", "scheduler_inspector"),
+                metadata={"schedulers": list(schedulers)},
+            )
+        )
+
+    return plugins
+
+
+__all__ = [
+    "Capability",
+    "CapabilityNotAvailable",
+    "PluginRegistry",
+    "UiPluginDescriptor",
+    "discover_ui_plugins",
+    "registry",
+]
diff --git a/src/molexp/plugins/agent_pydanticai/__init__.py b/src/molexp/plugins/agent_pydanticai/__init__.py
new file mode 100644
index 00000000..7bcb5f65
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/__init__.py
@@ -0,0 +1,57 @@
+"""AI agent plugin (PydanticAI-based autonomous execution).
+
+Loaded lazily by :class:`~molexp.plugins.PluginRegistry`.
+Requires ``pydantic-ai``: ``pip install molexp[agent]``.
+
+Public API::
+
+    from molexp.plugins.agent_pydanticai import AgentService, Goal
+    service = AgentService.from_workspace("./lab")
+    session = await service.run(Goal(description="..."))
+"""
+
+from .policy import ApprovalPolicy
+from .runtime import AgentRuntime
+from .service import AgentService
+from .tools import Tool, agent_tool
+from .types import (
+    AgentSession,
+    ApprovalRequestEvent,
+    Goal,
+    ObservationEvent,
+    PlanCreatedEvent,
+    ReplanEvent,
+    SessionCompletedEvent,
+    SessionEvent,
+    ToolCallEvent,
+    ToolContext,
+    ToolResultEvent,
+    WorkflowStartedEvent,
+)
+
+__all__ = [
+    "AgentService",
+    "AgentRuntime",
+    "AgentSession",
+    "ApprovalPolicy",
+    "Goal",
+    "Tool",
+    "ToolContext",
+    "agent_tool",
+    "SessionEvent",
+    "PlanCreatedEvent",
+    "ToolCallEvent",
+    "ToolResultEvent",
+    "WorkflowStartedEvent",
+    "ObservationEvent",
+    "ReplanEvent",
+    "ApprovalRequestEvent",
+    "SessionCompletedEvent",
+]
+
+
+def get_agent_plugin():
+    """Entry point for :class:`~molexp.plugins.PluginRegistry`."""
+    import pydantic_ai  # noqa: F401 — availability check
+
+    return AgentService
diff --git a/src/molexp/plugins/agent_pydanticai/_pydantic_ai/__init__.py b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/__init__.py
new file mode 100644
index 00000000..3f7b3ff9
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/__init__.py
@@ -0,0 +1,5 @@
+"""PydanticAI concrete implementation of molexp agent layer."""
+
+from .runtime import PydanticAIRuntime
+
+__all__ = ["PydanticAIRuntime"]
diff --git a/src/molexp/plugins/agent_pydanticai/_pydantic_ai/catalog.py b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/catalog.py
new file mode 100644
index 00000000..417dd322
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/catalog.py
@@ -0,0 +1,140 @@
+"""MolexpToolCatalog: builds a pydantic-ai toolset from molexp tools.
+
+Combines:
+1. Built-in Level 1/2/3 workspace tools
+2. User-provided extra tools (molexp Tool instances or pydantic-ai tools)
+3. ApprovalPolicy applied via pydantic-ai's approval_required() wrapper
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic_ai.toolsets import AbstractToolset, FunctionToolset
+
+from ..policy import ApprovalPolicy
+from ..tools import FunctionTool
+from ..tools import Tool as MolexpTool
+from ..types import ToolContext
+from .deps import MolexpDeps
+from .workspace_tools import get_all_builtin_tools
+
+
+class MolexpToolCatalog:
+    """Assembles the complete pydantic-ai toolset for a molexp agent session.
+
+    Built-in tools cover Level 1 (workspace read) and Level 3 (create run).
+    Level 2 workflow tools will be added in Phase 3.
+
+    Args:
+        extra_tools: User-provided additional tools (molexp.agent.Tool instances
+                     or raw pydantic-ai tool functions)
+        approval_policy: Policy controlling which tools need human approval
+    """
+
+    def __init__(
+        self,
+        extra_tools: list[Any] | None = None,
+        approval_policy: ApprovalPolicy | None = None,
+    ) -> None:
+        self._extra_tools = extra_tools or []
+        self._approval_policy = approval_policy or ApprovalPolicy()
+
+    def build(self) -> AbstractToolset[MolexpDeps]:
+        """Build and return the complete toolset.
+
+        Returns:
+            AbstractToolset ready to pass to pydantic-ai Agent
+        """
+        toolset: FunctionToolset[MolexpDeps] = FunctionToolset(
+            tools=get_all_builtin_tools()
+        )
+
+        # Add user extra tools
+        for tool in self._extra_tools:
+            if hasattr(tool, "_tool_registration"):
+                # @agent_tool decorated function → extract inner function
+                registration: FunctionTool = tool._tool_registration
+                wrapper = _make_pydantic_ai_wrapper(registration)
+                toolset.add_function(wrapper)
+            elif isinstance(tool, MolexpTool):
+                # OOP Tool subclass instance
+                wrapper = _make_pydantic_ai_wrapper_from_tool(tool)
+                toolset.add_function(wrapper)
+            elif callable(tool):
+                # Already a pydantic-ai compatible function (takes RunContext first)
+                toolset.add_function(tool)
+
+        # Apply approval policy via pydantic-ai's built-in mechanism
+        if self._approval_policy.require_approval_for:
+            policy = self._approval_policy
+
+            def approval_required_func(
+                ctx: Any, tool_def: Any, tool_args: dict[str, Any]
+            ) -> bool:
+                return policy.needs_approval(tool_def.name)
+
+            return toolset.approval_required(approval_required_func)
+
+        return toolset
+
+
+def _make_pydantic_ai_wrapper(registration: FunctionTool):
+    """Wrap a molexp FunctionTool as a pydantic-ai tool function.
+
+    The wrapper adapts `fn(ctx: ToolContext, **kwargs)` to the
+    pydantic-ai `fn(ctx: RunContext[MolexpDeps], **kwargs)` signature.
+
+    Note: Type annotations from the original function are preserved
+    (minus the ToolContext first arg) so pydantic-ai can generate
+    the correct JSON schema.
+    """
+    import inspect
+
+    from pydantic_ai import RunContext
+
+    original_fn = registration._fn
+    sig = inspect.signature(original_fn)
+    params = list(sig.parameters.values())
+
+    # Remove first param (ToolContext ctx)
+    _inner_params = [p for p in params if p.annotation is not ToolContext
+                     and p.name not in ("ctx", "context")]
+
+    async def wrapper(ctx: RunContext[MolexpDeps], **kwargs: Any) -> Any:
+        tool_ctx = ToolContext(
+            workspace=ctx.deps.workspace,
+            run=ctx.deps.current_run,
+            session=ctx.deps.session,
+        )
+        return await registration._fn(tool_ctx, **kwargs)
+
+    wrapper.__name__ = registration.name.replace(".", "_")
+    wrapper.__doc__ = original_fn.__doc__ or f"Tool: {registration.name}"
+
+    # Copy annotations (skip ToolContext ctx arg)
+    annotations = {
+        k: v for k, v in getattr(original_fn, "__annotations__", {}).items()
+        if k not in ("ctx", "context", "return")
+    }
+    annotations["ctx"] = RunContext[MolexpDeps]
+    wrapper.__annotations__ = annotations
+
+    return wrapper
+
+
+def _make_pydantic_ai_wrapper_from_tool(tool: MolexpTool):
+    """Wrap an OOP Tool instance as a pydantic-ai tool function."""
+    from pydantic_ai import RunContext
+
+    async def wrapper(ctx: RunContext[MolexpDeps], **kwargs: Any) -> Any:
+        tool_ctx = ToolContext(
+            workspace=ctx.deps.workspace,
+            run=ctx.deps.current_run,
+            session=ctx.deps.session,
+        )
+        return await tool.call(tool_ctx, **kwargs)
+
+    wrapper.__name__ = type(tool).__name__
+    wrapper.__doc__ = tool.__doc__ or f"Tool: {tool.name}"
+    return wrapper
diff --git a/src/molexp/plugins/agent_pydanticai/_pydantic_ai/deps.py b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/deps.py
new file mode 100644
index 00000000..ed84908b
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/deps.py
@@ -0,0 +1,23 @@
+"""MolexpDeps: dependency injection container for pydantic-ai agent runs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class MolexpDeps:
+    """Dependencies injected into every tool call via RunContext[MolexpDeps].
+
+    Attributes:
+        workspace: Root Workspace instance for project/experiment/run access
+        session_id: ID of the current agent session
+        session: PydanticAISession reference (for tool → ToolContext bridge)
+        current_run: Active Run if a workflow is currently executing
+    """
+
+    workspace: Any
+    session_id: str
+    session: Any = None
+    current_run: Any = None
diff --git a/src/molexp/plugins/agent_pydanticai/_pydantic_ai/events.py b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/events.py
new file mode 100644
index 00000000..872494e8
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/events.py
@@ -0,0 +1,67 @@
+"""Event mapping: pydantic-ai AgentStreamEvent → molexp SessionEvent.
+
+The pydantic-ai event stream contains low-level model events
+(text deltas, tool calls, tool results). We map the relevant
+ones to molexp's higher-level session event types.
+
+Mapping table (§6.6 of proposal):
+    FunctionToolCallEvent  → ToolCallEvent
+    FunctionToolResultEvent → ToolResultEvent
+    FinalResultEvent       → (ignored — SessionCompletedEvent is emitted separately)
+    PartStartEvent (text)  → ObservationEvent (when agent produces text)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic_ai.messages import (
+    AgentStreamEvent,
+    FunctionToolCallEvent,
+    FunctionToolResultEvent,
+    PartStartEvent,
+)
+
+from ..types import (
+    ObservationEvent,
+    SessionEvent,
+    ToolCallEvent,
+    ToolResultEvent,
+)
+
+
+def map_stream_event(event: AgentStreamEvent) -> SessionEvent | None:
+    """Map a pydantic-ai stream event to a molexp SessionEvent.
+
+    Returns None for events that don't have a molexp equivalent
+    (e.g., streaming text deltas, thinking parts).
+    """
+    if isinstance(event, FunctionToolCallEvent):
+        args = event.part.args
+        if isinstance(args, str):
+            try:
+                import json
+                args = json.loads(args)
+            except Exception:
+                args = {"raw": args}
+        return ToolCallEvent(
+            tool_name=event.part.tool_name,
+            args=args if isinstance(args, dict) else {"value": args},
+        )
+
+    if isinstance(event, FunctionToolResultEvent):
+        result_part = event.result
+        result_value: Any = getattr(result_part, "content", str(result_part))
+        return ToolResultEvent(
+            tool_name=getattr(result_part, "tool_name", "unknown"),
+            result=result_value,
+        )
+
+    if isinstance(event, PartStartEvent):
+        # Emit text parts as observations (agent's reasoning/response text)
+        part = event.part
+        if hasattr(part, "content") and isinstance(part.content, str) and part.content.strip():
+            return ObservationEvent(content=part.content[:500])
+
+    # FinalResultEvent, PartDeltaEvent, PartEndEvent → not mapped
+    return None
diff --git a/src/molexp/plugins/agent_pydanticai/_pydantic_ai/runtime.py b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/runtime.py
new file mode 100644
index 00000000..f3a8567f
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/runtime.py
@@ -0,0 +1,237 @@
+"""PydanticAIRuntime: concrete AgentRuntime implementation.
+
+Wraps pydantic-ai Agent with:
+- MolexpToolCatalog (built-in + user tools)
+- ApprovalPolicy via pydantic-ai's approval_required()
+- Session persistence in workspace sessions/ directory
+- Message history for cross-process resumption
+"""
+
+from __future__ import annotations
+
+import json
+from mollog import get_logger
+import uuid
+from pathlib import Path
+from typing import Any
+
+from pydantic_ai import Agent
+
+from ..policy import ApprovalPolicy
+from ..runtime import AgentRuntime
+from ..tools import Tool
+from ..types import (
+    AgentSession,
+    Goal,
+    ToolContext,  # noqa: F401 - re-exported for tool wrappers
+)
+from .catalog import MolexpToolCatalog
+from .deps import MolexpDeps
+from .session import PydanticAISession
+
+logger = get_logger(__name__)
+
+_SYSTEM_PROMPT = """\
+You are a research experiment assistant integrated with the molexp workspace.
+
+Your role:
+1. Understand the user's research goal and any constraints
+2. Plan a sequence of steps to achieve the goal
+3. Use the available tools to explore the workspace, create runs, and execute workflows
+4. Observe results and adjust your plan as needed
+5. Report clearly when the goal is achieved or when it cannot be met
+
+Available tool levels:
+- Workspace tools: list and inspect projects, experiments, runs (read-only)
+- Product tools: create new runs with specified parameters (write)
+- Workflow tools: execute workflows (available in Phase 3)
+
+Always start by exploring the workspace to understand the current state before taking actions.
+When creating runs, specify meaningful parameters that align with the research goal.
+"""
+
+
+class PydanticAIRuntime(AgentRuntime):
+    """AgentRuntime backed by pydantic-ai.
+
+    Creates a pydantic-ai Agent configured with the MolexpToolCatalog
+    and manages the session lifecycle including persistence.
+
+    Args:
+        model: pydantic-ai model name or instance (default: claude-sonnet-4-6)
+        sessions_dir_name: Workspace subdirectory for session persistence
+    """
+
+    def __init__(
+        self,
+        model: str = "anthropic:claude-sonnet-4-6",
+        sessions_dir_name: str = "sessions",
+    ) -> None:
+        self._model = model
+        self._sessions_dir_name = sessions_dir_name
+        self._active_sessions: dict[str, PydanticAISession] = {}
+
+    def _get_sessions_dir(self, workspace: Any) -> Path:
+        sessions_dir = Path(workspace.root) / self._sessions_dir_name
+        sessions_dir.mkdir(parents=True, exist_ok=True)
+        return sessions_dir
+
+    def _build_agent(
+        self,
+        extra_tools: list[Tool],
+        approval_policy: ApprovalPolicy,
+    ) -> Agent[MolexpDeps, str]:
+        catalog = MolexpToolCatalog(
+            extra_tools=extra_tools,
+            approval_policy=approval_policy,
+        )
+        toolset = catalog.build()
+
+        return Agent(
+            model=self._model,
+            system_prompt=_SYSTEM_PROMPT,
+            deps_type=MolexpDeps,
+            toolsets=[toolset],
+        )
+
+    def _goal_to_prompt(self, goal: Goal) -> str:
+        lines = [f"Goal: {goal.description}"]
+        if goal.constraints:
+            lines.append(f"Constraints: {goal.constraints}")
+        if goal.success_criteria:
+            lines.append("Success criteria:")
+            for criterion in goal.success_criteria:
+                lines.append(f"  - {criterion}")
+        return "\n".join(lines)
+
+    async def start_session(
+        self,
+        goal: Goal,
+        workspace: Any,
+        extra_tools: list[Tool],
+        approval_policy: ApprovalPolicy,
+    ) -> AgentSession:
+        session_id = f"sess-{uuid.uuid4().hex[:12]}"
+
+        session = PydanticAISession(
+            session_id=session_id,
+            goal=goal,
+            workspace=workspace,
+        )
+
+        deps = MolexpDeps(
+            workspace=workspace,
+            session_id=session_id,
+            session=session,
+        )
+
+        agent = self._build_agent(extra_tools, approval_policy)
+        prompt = self._goal_to_prompt(goal)
+
+        # Register before launching so persistence can find it
+        self._active_sessions[session_id] = session
+
+        # Persist session metadata
+        self._save_session_metadata(session, workspace)
+
+        # Launch agent run as background task
+        session._launch(agent=agent, prompt=prompt, deps=deps)
+
+        logger.info(f"Started agent session {session_id}")
+        return session
+
+    async def resume_session(
+        self,
+        session_id: str,
+        workspace: Any,
+    ) -> AgentSession:
+        sessions_dir = self._get_sessions_dir(workspace)
+        session_dir = sessions_dir / session_id
+
+        if not session_dir.exists():
+            raise ValueError(f"Session '{session_id}' not found in workspace")
+
+        # Load metadata
+        meta_path = session_dir / "metadata.json"
+        with meta_path.open() as f:
+            meta = json.load(f)
+
+        goal = Goal(
+            description=meta["goal"]["description"],
+            constraints=meta["goal"].get("constraints", {}),
+            success_criteria=meta["goal"].get("success_criteria", []),
+        )
+
+        session = PydanticAISession(
+            session_id=session_id,
+            goal=goal,
+            workspace=workspace,
+        )
+
+        # Restore message history if available
+        history_path = session_dir / "history.json"
+        if history_path.exists():
+            from pydantic_ai.messages import ModelMessagesTypeAdapter
+            with history_path.open("rb") as f:
+                history = ModelMessagesTypeAdapter.validate_json(f.read())
+            session.restore_message_history(history)
+
+        # Re-launch with empty extra_tools and default approval policy
+        # (user can pass updated tools via AgentService.resume)
+        deps = MolexpDeps(
+            workspace=workspace,
+            session_id=session_id,
+            session=session,
+        )
+        agent = self._build_agent([], ApprovalPolicy())
+        prompt = "Resume from where we left off and continue towards the original goal."
+
+        self._active_sessions[session_id] = session
+        session._launch(agent=agent, prompt=prompt, deps=deps)
+
+        logger.info(f"Resumed agent session {session_id}")
+        return session
+
+    async def get_session_history(self, session_id: str) -> Any:
+        session = self._active_sessions.get(session_id)
+        if session is not None:
+            return {"session_id": session_id, "messages": session.get_message_history()}
+        return {"session_id": session_id, "messages": []}
+
+    def _save_session_metadata(self, session: PydanticAISession, workspace: Any) -> None:
+        sessions_dir = self._get_sessions_dir(workspace)
+        session_dir = sessions_dir / session.session_id
+        session_dir.mkdir(parents=True, exist_ok=True)
+
+        meta = {
+            "session_id": session.session_id,
+            "status": session.status,
+            "goal": {
+                "description": session.goal.description,
+                "constraints": session.goal.constraints,
+                "success_criteria": session.goal.success_criteria,
+            },
+        }
+        meta_path = session_dir / "metadata.json"
+        tmp_path = meta_path.with_suffix(".tmp")
+        tmp_path.write_text(json.dumps(meta, indent=2))
+        tmp_path.rename(meta_path)
+
+    def save_session_history(self, session: PydanticAISession, workspace: Any) -> None:
+        """Persist message history for resumption (call after session completes)."""
+        try:
+            from pydantic_ai.messages import ModelMessagesTypeAdapter
+            history = session.get_message_history()
+            if not history:
+                return
+            sessions_dir = self._get_sessions_dir(workspace)
+            session_dir = sessions_dir / session.session_id
+            session_dir.mkdir(parents=True, exist_ok=True)
+            history_path = session_dir / "history.json"
+            tmp_path = history_path.with_suffix(".tmp")
+            tmp_path.write_bytes(
+                ModelMessagesTypeAdapter.dump_json(history, indent=2)
+            )
+            tmp_path.rename(history_path)
+        except Exception:
+            logger.exception(f"Failed to save session history for {session.session_id}")
diff --git a/src/molexp/plugins/agent_pydanticai/_pydantic_ai/session.py b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/session.py
new file mode 100644
index 00000000..2b8120e1
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/session.py
@@ -0,0 +1,137 @@
+"""PydanticAISession: concrete AgentSession implementation.
+
+Design:
+- Agent run executes as an asyncio.Task (background coroutine)
+- Events are forwarded through an asyncio.Queue to stream_events()
+- Approval requests use asyncio.Future for suspend/resume
+- Session state is persisted to workspace after completion
+"""
+
+from __future__ import annotations
+
+import asyncio
+from mollog import get_logger
+from typing import TYPE_CHECKING, Any, AsyncIterator
+
+from pydantic_ai import Agent
+from pydantic_ai.messages import AgentStreamEvent
+
+from ..types import (
+    AgentSession,
+    Goal,
+    SessionCompletedEvent,
+    SessionEvent,
+)
+from .events import map_stream_event
+
+if TYPE_CHECKING:
+    from .deps import MolexpDeps
+
+logger = get_logger(__name__)
+
+_DONE = object()  # Sentinel to signal stream_events() to stop
+
+
+class PydanticAISession(AgentSession):
+    """AgentSession backed by a pydantic-ai Agent run.
+
+    The agent run is launched as an asyncio.Task immediately after
+    construction. Events flow from the agent run → asyncio.Queue →
+    stream_events() async iterator.
+
+    Approval flow:
+        1. ApprovalRequiredToolset raises ApprovalRequired
+        2. The agent run gets DeferredToolRequests
+        3. We emit ApprovalRequestEvent to the queue
+        4. respond_approval() resolves the pending Future
+        5. The agent run resumes with approved=True/False
+    """
+
+    def __init__(
+        self,
+        session_id: str,
+        goal: Goal,
+        workspace: Any,
+    ) -> None:
+        super().__init__(session_id=session_id, goal=goal)
+        self._workspace = workspace
+        self._event_queue: asyncio.Queue[Any] = asyncio.Queue()
+        self._approval_futures: dict[str, asyncio.Future[bool]] = {}
+        self._run_task: asyncio.Task | None = None
+        self._message_history: list[Any] = []
+
+    def _launch(self, agent: Agent, prompt: str, deps: MolexpDeps) -> None:
+        """Start the agent run as a background asyncio.Task."""
+        self._run_task = asyncio.create_task(
+            self._run_agent(agent, prompt, deps),
+            name=f"molexp-session-{self.session_id}",
+        )
+
+    async def _run_agent(self, agent: Agent, prompt: str, deps: MolexpDeps) -> None:
+        """Background coroutine: runs the agent and forwards events."""
+        try:
+            event_queue = self._event_queue
+
+            async def handle_events(
+                ctx: Any, events: AsyncIterator[AgentStreamEvent]
+            ) -> None:
+                async for raw_event in events:
+                    molexp_event = map_stream_event(raw_event)
+                    if molexp_event is not None:
+                        await event_queue.put(molexp_event)
+
+            result = await agent.run(
+                prompt,
+                deps=deps,
+                event_stream_handler=handle_events,
+                message_history=self._message_history or None,
+            )
+
+            # Persist message history for potential resumption
+            self._message_history = result.all_messages()
+
+            self.status = "completed"
+            completed_event = SessionCompletedEvent(
+                summary=str(result.output),
+                produced_runs=list(self.produced_runs),
+                artifacts=list(self.artifacts),
+            )
+            await event_queue.put(completed_event)
+
+        except Exception as exc:
+            logger.exception(f"Agent session {self.session_id} failed")
+            self.status = "failed"
+            await event_queue.put(
+                SessionCompletedEvent(summary=f"Session failed: {exc}")
+            )
+        finally:
+            await self._event_queue.put(_DONE)
+
+    async def stream_events(self) -> AsyncIterator[SessionEvent]:
+        """Yield session events until the run completes."""
+        while True:
+            item = await self._event_queue.get()
+            if item is _DONE:
+                return
+            yield item
+
+    async def respond_approval(self, request_id: str, approved: bool) -> None:
+        """Resolve a pending approval request.
+
+        Args:
+            request_id: ID from the ApprovalRequestEvent
+            approved: True to allow, False to deny
+        """
+        future = self._approval_futures.get(request_id)
+        if future is not None and not future.done():
+            future.set_result(approved)
+        else:
+            logger.warning(f"No pending approval request for id={request_id}")
+
+    def get_message_history(self) -> list[Any]:
+        """Return the accumulated message history for persistence/resumption."""
+        return list(self._message_history)
+
+    def restore_message_history(self, history: list[Any]) -> None:
+        """Restore message history for a resumed session."""
+        self._message_history = list(history)
diff --git a/src/molexp/plugins/agent_pydanticai/_pydantic_ai/workspace_tools.py b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/workspace_tools.py
new file mode 100644
index 00000000..6e972aa6
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/_pydantic_ai/workspace_tools.py
@@ -0,0 +1,191 @@
+"""Built-in molexp workspace tools for the agent layer.
+
+Three access levels (per proposal §6.5):
+
+Level 1 — Workspace tools (read-only, never require approval)
+  list_projects, list_experiments, list_runs, get_run_summary
+
+Level 2 — Workflow tools (execution, Phase 3 will add these)
+  workflow_execute (stubbed — NotImplementedError until Phase 3)
+
+Level 3 — Product tools (write operations, some require approval)
+  create_run
+
+All functions take `RunContext[MolexpDeps]` as first argument so
+pydantic-ai recognises them as context-aware tools.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic_ai import RunContext
+
+from .deps import MolexpDeps
+
+# ── Level 1: Workspace read-only tools ────────────────────────────────────────
+
+async def list_projects(ctx: RunContext[MolexpDeps]) -> list[dict[str, Any]]:
+    """List all projects in the workspace.
+
+    Returns a list of project summaries with id and name.
+    """
+    projects = ctx.deps.workspace.list_projects()
+    return [
+        {
+            "id": p.id,
+            "name": p.metadata.name,
+            "description": getattr(p.metadata, "description", ""),
+        }
+        for p in projects
+    ]
+
+
+async def list_experiments(
+    ctx: RunContext[MolexpDeps], project_id: str
+) -> list[dict[str, Any]]:
+    """List all experiments in a project.
+
+    Args:
+        project_id: ID of the project to list experiments for
+    """
+    project = ctx.deps.workspace.get_project(project_id)
+    if project is None:
+        return {"error": f"Project '{project_id}' not found"}  # type: ignore[return-value]
+    experiments = project.list_experiments()
+    return [
+        {
+            "id": e.id,
+            "name": e.metadata.name,
+            "description": getattr(e.metadata, "description", ""),
+        }
+        for e in experiments
+    ]
+
+
+async def list_runs(
+    ctx: RunContext[MolexpDeps], project_id: str, experiment_id: str
+) -> list[dict[str, Any]]:
+    """List all runs in an experiment.
+
+    Args:
+        project_id: ID of the project
+        experiment_id: ID of the experiment
+    """
+    project = ctx.deps.workspace.get_project(project_id)
+    if project is None:
+        return {"error": f"Project '{project_id}' not found"}  # type: ignore[return-value]
+    experiment = project.get_experiment(experiment_id)
+    if experiment is None:
+        return {"error": f"Experiment '{experiment_id}' not found"}  # type: ignore[return-value]
+    runs = experiment.list_runs()
+    return [
+        {
+            "id": r.id,
+            "status": str(r.status),
+            "parameters": getattr(r, "parameters", {}),
+        }
+        for r in runs
+    ]
+
+
+async def get_run_summary(
+    ctx: RunContext[MolexpDeps],
+    project_id: str,
+    experiment_id: str,
+    run_id: str,
+) -> dict[str, Any]:
+    """Get a detailed summary of a specific run.
+
+    Args:
+        project_id: ID of the project
+        experiment_id: ID of the experiment
+        run_id: ID of the run
+    """
+    project = ctx.deps.workspace.get_project(project_id)
+    if project is None:
+        return {"error": f"Project '{project_id}' not found"}
+    experiment = project.get_experiment(experiment_id)
+    if experiment is None:
+        return {"error": f"Experiment '{experiment_id}' not found"}
+    run = experiment.get_run(run_id)
+    if run is None:
+        return {"error": f"Run '{run_id}' not found"}
+    return {
+        "id": run.id,
+        "status": str(run.status),
+        "parameters": getattr(run, "parameters", {}),
+        "metadata": {
+            "created_at": str(getattr(run.metadata, "created_at", "")),
+            "finished_at": str(getattr(run.metadata, "finished_at", "")),
+        },
+    }
+
+
+# ── Level 2: Workflow tools (Phase 3) ────────────────────────────────────────
+
+async def workflow_execute(
+    ctx: RunContext[MolexpDeps],
+    project_id: str,
+    experiment_id: str,
+    run_id: str,
+    workflow_spec_json: str,
+) -> dict[str, Any]:
+    """Execute a workflow for a given run.
+
+    Note: Full implementation available in Phase 3 (pydantic-graph runtime).
+
+    Args:
+        project_id: ID of the project
+        experiment_id: ID of the experiment
+        run_id: ID of the run to execute in
+        workflow_spec_json: JSON-serialized WorkflowSpec
+    """
+    return {
+        "error": "not_implemented",
+        "message": (
+            "Workflow execution will be available in Phase 3 "
+            "(pydantic-graph runtime integration)."
+        ),
+    }
+
+
+# ── Level 3: Product write tools ──────────────────────────────────────────────
+
+async def create_run(
+    ctx: RunContext[MolexpDeps],
+    project_id: str,
+    experiment_id: str,
+    parameters: dict[str, Any],
+) -> dict[str, Any]:
+    """Create a new run in an experiment with specified parameters.
+
+    Args:
+        project_id: ID of the project
+        experiment_id: ID of the experiment
+        parameters: Hyperparameters and configuration for this run
+    """
+    project = ctx.deps.workspace.get_project(project_id)
+    if project is None:
+        return {"error": f"Project '{project_id}' not found"}
+    experiment = project.get_experiment(experiment_id)
+    if experiment is None:
+        return {"error": f"Experiment '{experiment_id}' not found"}
+    run = experiment.run(parameters=parameters)
+    return {
+        "run_id": run.id,
+        "status": str(run.status),
+        "parameters": parameters,
+    }
+
+
+def get_all_builtin_tools() -> list:
+    """Return all built-in tool functions for catalog registration."""
+    return [
+        list_projects,
+        list_experiments,
+        list_runs,
+        get_run_summary,
+        workflow_execute,
+        create_run,
+    ]
diff --git a/src/molexp/plugins/agent_pydanticai/policy.py b/src/molexp/plugins/agent_pydanticai/policy.py
new file mode 100644
index 00000000..6ecad413
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/policy.py
@@ -0,0 +1,37 @@
+"""ApprovalPolicy: controls which tools require human approval."""
+
+from __future__ import annotations
+
+import fnmatch
+
+
+class ApprovalPolicy:
+    """Defines which tool calls require human approval.
+
+    Patterns are glob-style. auto_approve takes precedence.
+
+    Example::
+
+        policy = ApprovalPolicy(
+            require_approval_for=["product.*", "workflow.execute"],
+            auto_approve=["workspace.read_*", "workflow.inspect"],
+        )
+    """
+
+    def __init__(
+        self,
+        require_approval_for: list[str] | None = None,
+        auto_approve: list[str] | None = None,
+    ) -> None:
+        self.require_approval_for: list[str] = require_approval_for or []
+        self.auto_approve: list[str] = auto_approve or []
+
+    def needs_approval(self, tool_name: str) -> bool:
+        """Check whether a tool invocation requires approval."""
+        for pattern in self.auto_approve:
+            if fnmatch.fnmatch(tool_name, pattern):
+                return False
+        for pattern in self.require_approval_for:
+            if fnmatch.fnmatch(tool_name, pattern):
+                return True
+        return False
diff --git a/src/molexp/plugins/agent_pydanticai/runtime.py b/src/molexp/plugins/agent_pydanticai/runtime.py
new file mode 100644
index 00000000..9f7c80c7
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/runtime.py
@@ -0,0 +1,70 @@
+"""Abstract AgentRuntime interface.
+
+Internal adapter contract — users never see this.
+Phase 2 will provide PydanticAIRuntime as the concrete implementation.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from .policy import ApprovalPolicy
+from .tools import Tool
+from .types import AgentSession, Goal
+
+
+class AgentRuntime(ABC):
+    """Abstract interface for agent execution backends."""
+
+    @abstractmethod
+    async def start_session(
+        self,
+        goal: Goal,
+        workspace: Any,
+        extra_tools: list[Tool],
+        approval_policy: ApprovalPolicy,
+    ) -> AgentSession: ...
+
+    @abstractmethod
+    async def resume_session(self, session_id: str, workspace: Any) -> AgentSession: ...
+
+    @abstractmethod
+    async def get_session_history(self, session_id: str) -> Any: ...
+
+
+class _NotImplementedAgentRuntime(AgentRuntime):
+    """Placeholder until Phase 2 PydanticAI implementation."""
+
+    _MSG = (
+        "AgentRuntime is not yet implemented. "
+        "See Phase 2 of the pydantic-graph integration proposal."
+    )
+
+    async def start_session(self, goal: Goal, workspace: Any, extra_tools: list[Tool], approval_policy: ApprovalPolicy) -> AgentSession:
+        raise NotImplementedError(self._MSG)
+
+    async def resume_session(self, session_id: str, workspace: Any) -> AgentSession:
+        raise NotImplementedError(self._MSG)
+
+    async def get_session_history(self, session_id: str) -> Any:
+        raise NotImplementedError(self._MSG)
+
+
+def create_default_agent_runtime() -> AgentRuntime:
+    """Instantiate the appropriate AgentRuntime.
+
+    Returns PydanticAIRuntime (Phase 2 implementation).
+    Override the model via molcfg config (key: ``agent.model``).
+    """
+    try:
+        from molcfg import ConfigLoader, DictSource
+
+        from ._pydantic_ai import PydanticAIRuntime
+
+        sources = [DictSource({"agent": {"model": "anthropic:claude-sonnet-4-6"}})]
+        config = ConfigLoader(sources).load()
+        model = config["agent.model"]
+        return PydanticAIRuntime(model=model)
+    except ImportError:
+        return _NotImplementedAgentRuntime()
diff --git a/src/molexp/plugins/agent_pydanticai/service.py b/src/molexp/plugins/agent_pydanticai/service.py
new file mode 100644
index 00000000..d635b386
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/service.py
@@ -0,0 +1,79 @@
+"""AgentService: entry point for goal-driven autonomous execution."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from molexp.workspace import Workspace
+
+from .policy import ApprovalPolicy
+from .runtime import AgentRuntime, create_default_agent_runtime
+from .tools import Tool
+from .types import AgentSession, Goal
+
+
+class AgentService:
+    """Service for creating and managing agent sessions.
+
+    Example::
+
+        service = AgentService.from_workspace("./lab")
+        session = await service.run(goal)
+        print(session.produced_runs)
+    """
+
+    def __init__(
+        self,
+        workspace: Any,
+        runtime: AgentRuntime,
+        extra_tools: list[Tool] | None = None,
+        approval_policy: ApprovalPolicy | None = None,
+    ) -> None:
+        self._workspace = workspace
+        self._runtime = runtime
+        self._extra_tools: list[Tool] = extra_tools or []
+        self._approval_policy = approval_policy or ApprovalPolicy()
+
+    @classmethod
+    def from_workspace(
+        cls,
+        workspace_path: str,
+        extra_tools: list[Tool] | None = None,
+        approval_policy: ApprovalPolicy | None = None,
+    ) -> AgentService:
+        """Create an AgentService from a workspace directory path."""
+        workspace = Workspace(workspace_path)
+        runtime = create_default_agent_runtime()
+        return cls(
+            workspace=workspace,
+            runtime=runtime,
+            extra_tools=extra_tools,
+            approval_policy=approval_policy,
+        )
+
+    async def run(self, goal: Goal) -> AgentSession:
+        """Run a goal to completion and return the completed session."""
+        session = await self.start(goal)
+        async for _ in session.stream_events():
+            pass  # drain until SessionCompletedEvent
+        return session
+
+    async def start(self, goal: Goal) -> AgentSession:
+        """Start a goal-driven agent session asynchronously."""
+        return await self._runtime.start_session(
+            goal=goal,
+            workspace=self._workspace,
+            extra_tools=self._extra_tools,
+            approval_policy=self._approval_policy,
+        )
+
+    async def resume(self, session_id: str) -> AgentSession:
+        """Resume a previously suspended session."""
+        return await self._runtime.resume_session(
+            session_id=session_id,
+            workspace=self._workspace,
+        )
+
+    async def get_session_history(self, session_id: str) -> Any:
+        """Retrieve the full event timeline for a completed session."""
+        return await self._runtime.get_session_history(session_id)
diff --git a/src/molexp/plugins/agent_pydanticai/tools.py b/src/molexp/plugins/agent_pydanticai/tools.py
new file mode 100644
index 00000000..4c4d5365
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/tools.py
@@ -0,0 +1,90 @@
+"""Tool base class and @agent_tool decorator.
+
+Two equivalent ways to register tools:
+
+Decorator style::
+
+    @agent_tool(level="workspace", requires_approval=False)
+    async def read_asset(ctx: ToolContext, asset_name: str) -> AssetContent:
+        return ctx.workspace.assets.read(asset_name)
+
+OOP style::
+
+    class ReadAssetTool(Tool):
+        name = "workspace.read_asset"
+        level = "workspace"
+        requires_approval = False
+
+        async def call(self, ctx: ToolContext, asset_name: str) -> AssetContent:
+            return ctx.workspace.assets.read(asset_name)
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import Any
+
+from .types import ToolContext
+
+
+class Tool(ABC):
+    """Abstract base class for OOP-style agent tools."""
+
+    name: str = ""
+    level: str = "workspace"
+    requires_approval: bool = False
+
+    @abstractmethod
+    async def call(self, ctx: ToolContext, **kwargs: Any) -> Any:
+        """Execute the tool."""
+        ...
+
+
+class FunctionTool(Tool):
+    """Adapts a decorated function into a Tool instance."""
+
+    def __init__(
+        self,
+        fn: Callable,
+        name: str,
+        level: str,
+        requires_approval: bool,
+    ) -> None:
+        self._fn = fn
+        self.name = name
+        self.level = level
+        self.requires_approval = requires_approval
+
+    async def call(self, ctx: ToolContext, **kwargs: Any) -> Any:
+        return await self._fn(ctx, **kwargs)
+
+
+def agent_tool(
+    fn: Callable | None = None,
+    *,
+    level: str = "workspace",
+    requires_approval: bool = False,
+    name: str | None = None,
+) -> Callable:
+    """Decorator to register a function as an agent tool.
+
+    Usage::
+
+        @agent_tool(level="product", requires_approval=True)
+        async def run_training(ctx: ToolContext, ...) -> ...: ...
+    """
+    def decorator(f: Callable) -> Callable:
+        tool_name = name or f.__name__
+        tool_instance = FunctionTool(
+            fn=f,
+            name=tool_name,
+            level=level,
+            requires_approval=requires_approval,
+        )
+        f._tool_registration = tool_instance
+        return f
+
+    if fn is not None:
+        return decorator(fn)
+    return decorator
diff --git a/src/molexp/plugins/agent_pydanticai/types.py b/src/molexp/plugins/agent_pydanticai/types.py
new file mode 100644
index 00000000..83fcaf37
--- /dev/null
+++ b/src/molexp/plugins/agent_pydanticai/types.py
@@ -0,0 +1,114 @@
+"""Core types for the molexp agent layer."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, AsyncIterator
+
+
+@dataclass
+class Goal:
+    """A user-specified objective for autonomous agent execution."""
+    description: str
+    constraints: dict[str, Any] = field(default_factory=dict)
+    success_criteria: list[str] = field(default_factory=list)
+
+
+class ToolContext:
+    """Context passed to every agent tool invocation."""
+
+    def __init__(self, workspace: Any, run: Any, session: Any) -> None:
+        self.workspace = workspace
+        self.run = run
+        self.session = session
+
+
+@dataclass
+class PlanCreatedEvent:
+    plan_steps: list[str]
+    ts: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class ToolCallEvent:
+    tool_name: str
+    args: dict[str, Any]
+    ts: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class ToolResultEvent:
+    tool_name: str
+    result: Any
+    ts: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class WorkflowStartedEvent:
+    run_id: str
+    workflow_id: str | None = None
+    ts: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class ObservationEvent:
+    content: str
+    ts: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class ReplanEvent:
+    reason: str
+    new_plan: list[str] = field(default_factory=list)
+    ts: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class ApprovalRequestEvent:
+    request_id: str
+    tool_name: str
+    args: dict[str, Any]
+    ts: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class SessionCompletedEvent:
+    summary: str
+    produced_runs: list[Any] = field(default_factory=list)
+    artifacts: list[Any] = field(default_factory=list)
+    ts: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+SessionEvent = (
+    PlanCreatedEvent
+    | ToolCallEvent
+    | ToolResultEvent
+    | WorkflowStartedEvent
+    | ObservationEvent
+    | ReplanEvent
+    | ApprovalRequestEvent
+    | SessionCompletedEvent
+)
+
+
+class AgentSession(ABC):
+    """Handle for a running or completed agent session."""
+
+    def __init__(self, session_id: str, goal: Goal) -> None:
+        self.session_id = session_id
+        self.goal = goal
+        self.status: str = "running"
+        self.produced_runs: list[Any] = []
+        self.artifacts: list[Any] = []
+
+    @abstractmethod
+    async def stream_events(self) -> AsyncIterator[SessionEvent]:
+        """Stream session events in real time."""
+        ...
+
+    @abstractmethod
+    async def respond_approval(self, request_id: str, approved: bool) -> None:
+        """Respond to a human-in-the-loop approval request."""
+        ...
diff --git a/src/molexp/plugins/submit_molq/__init__.py b/src/molexp/plugins/submit_molq/__init__.py
new file mode 100644
index 00000000..c5ea20bf
--- /dev/null
+++ b/src/molexp/plugins/submit_molq/__init__.py
@@ -0,0 +1,6 @@
+"""molq submission plugin for ``molexp run``.
+
+Provides generic molq-backed scheduler submission, including the legacy
+``--slurm`` / ``--pbs`` / ``--lsf`` aliases and the newer
+``--scheduler <name>`` entry point.
+"""
diff --git a/src/molexp/plugins/submit_molq/metadata.py b/src/molexp/plugins/submit_molq/metadata.py
new file mode 100644
index 00000000..25320cdb
--- /dev/null
+++ b/src/molexp/plugins/submit_molq/metadata.py
@@ -0,0 +1,76 @@
+"""Helpers for molq-backed run metadata.
+
+This module must stay free of top-level ``molq`` imports so it can be used by
+CLI, monitor, and server code without making optional dependencies mandatory.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def supported_schedulers() -> tuple[str, ...]:
+    """Return scheduler backends supported by the installed ``molq``."""
+    try:
+        from molq.options import OPTIONS_TYPE_MAP
+    except ImportError:
+        return ()
+    return tuple(OPTIONS_TYPE_MAP.keys())
+
+
+def build_executor_info(
+    *,
+    scheduler: str,
+    cluster_name: str,
+    job_id: str | None,
+    scheduler_job_id: str | None,
+) -> dict[str, str]:
+    """Build normalized executor metadata persisted into ``run.json``."""
+    info = {
+        "backend": "molq",
+        "scheduler": scheduler,
+        "cluster_name": cluster_name,
+    }
+    if job_id:
+        info["job_id"] = job_id
+    if scheduler_job_id:
+        info["scheduler_job_id"] = scheduler_job_id
+    return info
+
+
+def normalize_executor_info(
+    raw: dict[str, Any] | None,
+    labels: dict[str, str] | None = None,
+) -> dict[str, str]:
+    """Normalize executor metadata with light backward compatibility."""
+    info: dict[str, str] = {}
+
+    if raw:
+        for key, value in raw.items():
+            if value is not None:
+                info[str(key)] = str(value)
+
+    if "job_id" not in info:
+        legacy_job_id = info.get("molq_job_id")
+        if legacy_job_id:
+            info["job_id"] = legacy_job_id
+
+    if "scheduler_job_id" not in info:
+        legacy_scheduler_job_id = info.get("slurm_job_id")
+        if legacy_scheduler_job_id:
+            info["scheduler_job_id"] = legacy_scheduler_job_id
+
+    label_map = labels or {}
+    for key in ("scheduler", "cluster_name", "scheduler_job_id"):
+        if key not in info and label_map.get(key):
+            info[key] = label_map[key]
+
+    if "job_id" not in info and label_map.get("molq_job_id"):
+        info["job_id"] = label_map["molq_job_id"]
+
+    if "backend" not in info and (
+        "job_id" in info or "scheduler_job_id" in info or "scheduler" in info
+    ):
+        info["backend"] = "molq"
+
+    return info
diff --git a/src/molexp/plugins/submit_molq/spec.py b/src/molexp/plugins/submit_molq/spec.py
new file mode 100644
index 00000000..b50a1f5c
--- /dev/null
+++ b/src/molexp/plugins/submit_molq/spec.py
@@ -0,0 +1,36 @@
+"""Remote execution spec models.
+
+Isolated from the core workflow layer so that ``import molexp.workflow``
+never triggers a ``molq`` import.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class EnvironmentSpec(BaseModel, frozen=True):
+    """Remote execution environment configuration."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    uv_lock: Path | None = None
+    python_version: str | None = None
+    env_vars: dict[str, str] = {}
+    setup_commands: list[str] = []
+
+
+class RemoteSpec(BaseModel, frozen=True):
+    """Remote execution target configuration."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    cluster: str
+    cluster_type: str = "slurm"
+    resources: Any = None
+    cluster_config: Any = None
+    env: EnvironmentSpec | None = None
+    transfer: Any = None
diff --git a/src/molexp/plugins/submit_molq/submit.py b/src/molexp/plugins/submit_molq/submit.py
new file mode 100644
index 00000000..8de49c1b
--- /dev/null
+++ b/src/molexp/plugins/submit_molq/submit.py
@@ -0,0 +1,156 @@
+"""Submission logic using molq types directly."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from .metadata import build_executor_info
+
+
+def _strip_none(d: dict[str, Any]) -> dict[str, Any]:
+    """Return a copy with ``None`` values removed."""
+    return {k: v for k, v in d.items() if v is not None}
+
+
+class SubmitHandler:
+    """Stateful run handler that submits jobs via molq.
+
+    Accumulates all submitted :class:`~molexp.workspace.run.Run` objects in
+    :attr:`submitted_runs` so the caller can pass them to a monitor after the
+    sweep completes.
+
+    Args:
+        scheduler: molq scheduler backend name.
+        cluster: molq cluster name (``None`` → ``"default"``).
+        resources: Sparse dict of resource overrides (``None`` values stripped).
+        scheduling: Sparse dict of scheduling overrides (``None`` values stripped).
+    """
+
+    def __init__(
+        self,
+        *,
+        scheduler: str,
+        cluster: str | None,
+        resources: dict[str, Any],
+        scheduling: dict[str, Any],
+        block: bool = False,
+    ) -> None:
+        self._scheduler = scheduler
+        self._cluster = cluster or "default"
+        self._res = _strip_none(resources)
+        self._sched = _strip_none(scheduling)
+        self._block = block
+        self._handles: list[Any] = []
+        self._submitor: Any = None
+        self.submitted_runs: list[Any] = []
+
+    # ------------------------------------------------------------------
+    # Callable protocol
+
+    def __call__(
+        self,
+        mol_run: Any,
+        experiment: Any,
+        project: Any,
+    ) -> None:
+        from molq import (
+            Duration,
+            JobExecution,
+            JobResources,
+            JobScheduling,
+            Memory,
+            Submitor,
+        )
+
+        res   = self._res
+        sched = self._sched
+
+        job_name = f"{project.name[:20]}-{mol_run.id[:8]}"
+        run_dir = Path(mol_run.run_dir)
+
+        # molq stores its own manifest under execution/; the actual execution
+        # sub-directories are created by RunContext when the job starts.
+        exec_root = run_dir / "execution"
+        exec_root.mkdir(parents=True, exist_ok=True)
+
+        with Submitor(
+            cluster_name=self._cluster,
+            scheduler=self._scheduler,
+            jobs_dir=str(exec_root),
+        ) as submitor:
+            job = submitor.submit(
+                argv=[
+                    sys.executable,
+                    "-m",
+                    "molexp.cli",
+                    "execute",
+                    str(run_dir),
+                ],
+                resources=JobResources(
+                    cpu_count=res.get("cpus"),
+                    memory=Memory.parse(res["mem"]) if res.get("mem") else None,
+                    gpu_count=res.get("gpus"),
+                    gpu_type=res.get("gpu_type"),
+                    time_limit=Duration.parse(res["time"]) if res.get("time") else None,
+                ),
+                scheduling=JobScheduling(
+                    queue=sched.get("queue"),
+                    account=sched.get("account"),
+                    qos=sched.get("qos"),
+                ),
+                execution=JobExecution(
+                    job_name=job_name,
+                    cwd=str(run_dir),
+                    output_file=str(run_dir / "stdout.log"),
+                    error_file=str(run_dir / "stderr.log"),
+                ),
+                metadata={
+                    "run_id":  mol_run.id,
+                    "run_dir": str(run_dir),
+                },
+            )
+
+        mol_run._update_metadata(
+            executor_info=build_executor_info(
+                scheduler=self._scheduler,
+                cluster_name=self._cluster,
+                job_id=job.job_id,
+                scheduler_job_id=job.scheduler_job_id,
+            )
+        )
+        self.submitted_runs.append(mol_run)
+
+
+def make_submit_handler(
+    *,
+    scheduler: str,
+    cluster: str | None,
+    resources: dict[str, Any],
+    scheduling: dict[str, Any],
+) -> SubmitHandler:
+    """Return a :class:`SubmitHandler` configured for the given scheduler.
+
+    The handler is callable with the standard ``(script, mol_run, experiment,
+    project)`` signature used by :func:`~molexp.cli._execute_sweep`.
+
+    All ``None`` values in *resources* and *scheduling* are stripped so that
+    molq passes them through as unset, letting each scheduler use its own
+    defaults.
+
+    Args:
+        scheduler: molq scheduler backend name.
+        cluster: molq cluster name; ``None`` defaults to ``"default"``.
+        resources: Resource options dict (``None`` values are stripped).
+        scheduling: Scheduling options dict (``None`` values are stripped).
+
+    Returns:
+        Configured :class:`SubmitHandler` instance.
+    """
+    return SubmitHandler(
+        scheduler=scheduler,
+        cluster=cluster,
+        resources=resources,
+        scheduling=scheduling,
+    )
diff --git a/src/molexp/schemas/__init__.py b/src/molexp/schemas/__init__.py
index a4f1b7eb..e822d8a1 100644
--- a/src/molexp/schemas/__init__.py
+++ b/src/molexp/schemas/__init__.py
@@ -1,9 +1,11 @@
 """JSON Schema utilities for Molexp documents."""
 
-from pathlib import Path
 import json
+from pathlib import Path
 from typing import Any
 
+from .validator import SchemaValidator, ValidationError
+
 SCHEMA_DIR = Path(__file__).parent
 
 
@@ -39,5 +41,3 @@ def list_schemas() -> list[str]:
 
 
 __all__ = ["get_schema", "list_schemas", "SCHEMA_DIR", "SchemaValidator", "ValidationError"]
-
-from .validator import SchemaValidator, ValidationError
diff --git a/src/molexp/schemas/validator.py b/src/molexp/schemas/validator.py
index 0acaad0d..261a2473 100644
--- a/src/molexp/schemas/validator.py
+++ b/src/molexp/schemas/validator.py
@@ -1,11 +1,10 @@
 """Schema validation utilities for Molexp documents."""
 
-from pathlib import Path
 from typing import Any
-import jsonschema
+
 from jsonschema import Draft7Validator, RefResolver
 
-from . import get_schema, SCHEMA_DIR
+from . import SCHEMA_DIR, get_schema
 
 
 class ValidationError(Exception):
diff --git a/src/molexp/server/__pycache__/__init__.cpython-312.pyc b/src/molexp/server/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index 1edb63fa..00000000
Binary files a/src/molexp/server/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/server/__pycache__/manager.cpython-312.pyc b/src/molexp/server/__pycache__/manager.cpython-312.pyc
deleted file mode 100644
index 9b9fb351..00000000
Binary files a/src/molexp/server/__pycache__/manager.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/server/app.py b/src/molexp/server/app.py
index 0d9d7b26..0241eb69 100644
--- a/src/molexp/server/app.py
+++ b/src/molexp/server/app.py
@@ -8,47 +8,123 @@
 
 from __future__ import annotations
 
-import logging
-import os
-from typing import Optional
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from pathlib import Path
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-
-from molexp.workflow.plugin import get_task_registry, load_plugins
+from mollog import get_logger
 
 from .handlers import register_exception_handlers
 from .routes import create_api_router
 from .schemas import HealthResponse
 
+logger = get_logger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
+    """Application lifespan: startup and shutdown events."""
+    logger.info("MolExp server starting up")
+    yield
+    logger.info("MolExp server shutting down")
+
+
+# ---------------------------------------------------------------------------
+# Bundled frontend discovery
+# ---------------------------------------------------------------------------
+
+
+def _find_bundled_webapp() -> Path | None:
+    """Locate the ``_webapp`` directory shipped inside the installed package.
+
+    Uses ``importlib.resources`` so this works regardless of whether the
+    package was installed from a wheel, an editable install, or a checkout.
+    Returns *None* when the frontend has not been compiled (normal in dev).
+    """
+    from importlib import resources
+
+    try:
+        pkg_path = Path(str(resources.files("molexp")))
+        webapp = pkg_path / "_webapp"
+        if webapp.is_dir() and (webapp / "index.html").exists():
+            return webapp
+    except Exception:  # noqa: BLE001
+        pass
+    return None
+
+
+# ---------------------------------------------------------------------------
+# SPA mount helper
+# ---------------------------------------------------------------------------
 
 
-def create_app(static_dir: Optional[str] = None) -> FastAPI:
+def _mount_webapp(app: FastAPI, webapp_dir: Path) -> None:
+    """Mount the React SPA and its static assets onto *app*.
+
+    Must be called **after** all ``/api`` routes have been registered so that
+    API routes take priority over the catch-all SPA fallback.
+    """
+    from fastapi.responses import FileResponse
+    from starlette.staticfiles import StaticFiles
+
+    index_html = str(webapp_dir / "index.html")
+
+    # Serve hashed JS / CSS / images produced by rsbuild
+    static_subdir = webapp_dir / "static"
+    if static_subdir.is_dir():
+        app.mount(
+            "/static",
+            StaticFiles(directory=str(static_subdir)),
+            name="webapp_static",
+        )
+
+    # SPA fallback — serves index.html for every non-API, non-static path
+    @app.get("/{full_path:path}", include_in_schema=False)
+    async def _spa_fallback(full_path: str) -> FileResponse:
+        # If an actual file exists at the root (favicon.ico, robots.txt, …)
+        candidate = webapp_dir / full_path
+        if full_path and candidate.is_file():
+            return FileResponse(str(candidate))
+        return FileResponse(index_html)
+
+
+# ---------------------------------------------------------------------------
+# Application factory
+# ---------------------------------------------------------------------------
+
+
+def create_app(
+    static_dir: str | Path | None = None,
+    *,
+    serve_static: bool = True,
+) -> FastAPI:
     """Create and configure the FastAPI application.
 
     Args:
-        static_dir: Directory containing built UI files (Production only).
-                    If provided, the app will serve these files at the root.
-                    If None, the app runs in API-only mode (Development).
+        static_dir: Explicit path to built UI files.  When *None* and
+            *serve_static* is ``True`` the bundled ``_webapp`` directory
+            is auto-detected via ``importlib.resources``.
+        serve_static: Set to ``False`` to run in API-only mode.
     """
     app = FastAPI(
         title="MolExp API",
-        version="0.3.0",
+        version="0.1.0",
         description="Research workflow management API",
-        docs_url="/api/docs",  # Move docs to distinct path
+        docs_url="/api/docs",
         openapi_url="/api/openapi.json",
+        lifespan=lifespan,
     )
 
     # 1. CORS Configuration (Dev Mode Support)
-    # Allows requests from standard frontend dev server ports.
     origins = [
         "http://localhost:3000",
         "http://localhost:5173",
         "http://127.0.0.1:3000",
         "http://127.0.0.1:5173",
     ]
-    
+
     app.add_middleware(
         CORSMiddleware,
         allow_origins=origins,
@@ -60,34 +136,49 @@ def create_app(static_dir: Optional[str] = None) -> FastAPI:
     # 2. Exception Handlers
     register_exception_handlers(app)
 
-    # 3. API Routes
-    # STRICT REQUIREMENT: All API routes must be under /api prefix
+    # 3. API Routes (all under /api prefix)
     api_router = create_api_router()
     app.include_router(api_router, prefix="/api")
 
-    # 4. Startup Events
-    @app.on_event("startup")
-    async def startup_event():
-        """Load node plugins at startup."""
-        try:
-            load_plugins()
-            registry = get_task_registry()
-            node_count = len(registry.list_all())
-            print(f"✓ Loaded {node_count} node types from plugins")
-        except Exception as e:
-            logging.warning(f"Failed to load plugins: {e}")
-
-    # 5. System Routes (Health Check)
+    # 4. System Routes (Health Check)
     @app.get("/api/health", response_model=HealthResponse, tags=["system"])
     def health_check() -> HealthResponse:
+        from molexp.plugins import Capability, registry
+
         return HealthResponse(
             status="healthy",
             workspace_available=True,
-            ir_available=True,
+            capabilities={
+                cap.value: registry.is_available(cap) for cap in Capability
+            },
         )
+
+    # 5. Static file serving (production) or root fallback (dev / no build)
+    webapp_path: Path | None = None
+    if serve_static:
+        if static_dir is not None:
+            webapp_path = Path(static_dir)
+        else:
+            webapp_path = _find_bundled_webapp()
+
+    if (
+        webapp_path is not None
+        and webapp_path.is_dir()
+        and (webapp_path / "index.html").exists()
+    ):
+        _mount_webapp(app, webapp_path)
+    else:
+        @app.get("/", tags=["system"])
+        def root():
+            return {
+                "service": "molexp",
+                "docs": "/api/docs",
+                "health": "/api/health",
+            }
+
     return app
 
 
-# Default app instance for Development Mode (uvicorn reload)
-# This instance runs in API-only mode (static_dir=None)
-app = create_app()
+# Default app instance for Development Mode (uvicorn --reload).
+# API-only — the frontend dev server (localhost:5173) runs separately.
+app = create_app(serve_static=False)
diff --git a/src/molexp/server/dependencies.py b/src/molexp/server/dependencies.py
index 86747bc2..6a6aa524 100644
--- a/src/molexp/server/dependencies.py
+++ b/src/molexp/server/dependencies.py
@@ -13,28 +13,35 @@
 
 from __future__ import annotations
 
-import os
 from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
+from molcfg import Config, ConfigLoader, DictSource
 from pydantic import BaseModel
 
 from molexp.workspace import Workspace
 
+_SERVER_DEFAULTS: dict[str, Any] = {
+    "workspace_path": "",
+    "debug": False,
+}
+
 
 class Settings(BaseModel):
-    """Application settings loaded from environment."""
+    """Application settings loaded via molcfg."""
 
     workspace_path: str = ""
     debug: bool = False
 
     @classmethod
-    def from_env(cls) -> "Settings":
-        """Create settings from environment variables."""
+    def from_config(cls, config: Config | None = None) -> Settings:
+        """Create settings from a molcfg Config."""
+        if config is None:
+            config = _load_server_config()
         return cls(
-            workspace_path=os.environ.get("MOLEXP_WORKSPACE", ""),
-            debug=os.environ.get("MOLEXP_DEBUG", "").lower() in ("true", "1", "yes"),
+            workspace_path=str(config.get("workspace_path", "")),
+            debug=bool(config.get("debug", False)),
         )
 
     def get_workspace_path(self) -> Path:
@@ -44,25 +51,47 @@ def get_workspace_path(self) -> Path:
         return Path.cwd()
 
 
+def _load_server_config() -> Config:
+    """Load server configuration from defaults + optional molexp.toml."""
+    sources = [DictSource(_SERVER_DEFAULTS)]
+    config_file = Path.cwd() / "molexp.toml"
+    if config_file.exists():
+        from molcfg import TomlFileSource
+
+        sources.append(TomlFileSource(str(config_file)))
+    return ConfigLoader(sources).load()
+
+
 @lru_cache
 def get_settings() -> Settings:
     """Get cached application settings."""
-    return Settings.from_env()
+    return Settings.from_config()
+
+
+_workspace_cache: dict[str, Workspace] = {}
 
 
-# Import Workspace lazily to avoid circular imports
 def get_workspace():
-    """FastAPI dependency to get Workspace instance.
+    """FastAPI dependency to get a cached Workspace instance.
+
+    The workspace is cached by resolved path so that repeated requests
+    do not recreate the object or re-read metadata from disk.
 
     Usage:
         @app.get("/api/projects")
         def list_projects(workspace: Workspace = Depends(get_workspace)):
             ...
     """
-    from molexp.workspace import Workspace
-
     workspace_path = get_workspace_path()
-    return Workspace.from_path(workspace_path)
+    cache_key = str(workspace_path.resolve())
+    if cache_key not in _workspace_cache:
+        _workspace_cache[cache_key] = Workspace.from_path(workspace_path)
+    return _workspace_cache[cache_key]
+
+
+def reset_workspace_cache() -> None:
+    """Clear the workspace cache (for testing or workspace switching)."""
+    _workspace_cache.clear()
 
 
 # ============================================================================
@@ -143,9 +172,14 @@ def reset_workspace_folder_store() -> None:
 
 
 def set_workspace_path_override(path: Path | None) -> None:
-    """Override workspace path at runtime."""
+    """Override workspace path at runtime.
+
+    Also clears the workspace cache so the next get_workspace() call
+    picks up the new path.
+    """
     global _workspace_path_override
     _workspace_path_override = path
+    reset_workspace_cache()
 
 
 def get_workspace_path() -> Path:
diff --git a/src/molexp/server/manager.py b/src/molexp/server/manager.py
index 6813c81d..78c0ea16 100644
--- a/src/molexp/server/manager.py
+++ b/src/molexp/server/manager.py
@@ -7,6 +7,8 @@
 import subprocess
 import sys
 import time
+import urllib.error
+import urllib.request
 from pathlib import Path
 from typing import Iterator
 
@@ -321,9 +323,6 @@ def _create_sample_data(self) -> None:
 
     def _wait_for_health(self, host: str, port: int, max_retries: int = 30) -> bool:
         """Wait for server to be healthy."""
-        import urllib.error
-        import urllib.request
-
         url = f"http://{host}:{port}/health"
 
         for _ in range(max_retries):
diff --git a/src/molexp/server/routes/__init__.py b/src/molexp/server/routes/__init__.py
index 8dc4203b..c10d3987 100644
--- a/src/molexp/server/routes/__init__.py
+++ b/src/molexp/server/routes/__init__.py
@@ -5,7 +5,7 @@
 
 from fastapi import APIRouter
 
-from . import asset, execution, experiment, registry, project, run, workspace
+from . import agent, asset, execution, experiment, project, registry, run, workspace
 
 
 def create_api_router() -> APIRouter:
@@ -16,7 +16,7 @@ def create_api_router() -> APIRouter:
     """
     api_router = APIRouter()
 
-    # Include all domain routers
+    api_router.include_router(agent.router)
     api_router.include_router(project.router)
     api_router.include_router(experiment.router)
     api_router.include_router(run.router)
@@ -30,6 +30,7 @@ def create_api_router() -> APIRouter:
 
 __all__ = [
     "create_api_router",
+    "agent",
     "project",
     "experiment",
     "run",
diff --git a/src/molexp/server/routes/agent.py b/src/molexp/server/routes/agent.py
new file mode 100644
index 00000000..42c8857c
--- /dev/null
+++ b/src/molexp/server/routes/agent.py
@@ -0,0 +1,115 @@
+"""Agent routes for MolExp API."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import AsyncGenerator
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+
+from molexp.plugins import Capability, registry
+from molexp.plugins.agent_pydanticai.types import Goal
+
+from ..dependencies import get_workspace
+from ..schemas import (
+    AgentSessionListResponse,
+    AgentSessionResponse,
+    ApprovalRespondRequest,
+    GoalCreateRequest,
+)
+
+router = APIRouter(prefix="/agent", tags=["agent"])
+
+# In-memory session store — NOT shared across workers.
+# Deploy with a single uvicorn worker (--workers 1) or replace with
+# an external store (Redis, database) before scaling horizontally.
+_sessions: dict[str, AgentSessionResponse] = {}
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+@router.post("/sessions", response_model=AgentSessionResponse)
+async def create_session(
+    request: GoalCreateRequest,
+    workspace=Depends(get_workspace),
+) -> AgentSessionResponse:
+    """Start a new agent session."""
+    goal = Goal(
+        description=request.description,
+        constraints=request.constraints,
+        success_criteria=request.success_criteria,
+    )
+
+    if not registry.is_available(Capability.AGENT):
+        raise HTTPException(501, "Agent capability not available. Install: pip install molexp[agent]")
+
+    try:
+        AgentService = registry.get(Capability.AGENT)
+        service = AgentService.from_workspace(str(workspace.root))
+        session = await service.start(goal)
+        response = AgentSessionResponse(
+            sessionId=session.session_id,
+            status=session.status,
+            goalDescription=goal.description,
+            createdAt=_now_iso(),
+            events=[],
+        )
+    except NotImplementedError:
+        raise HTTPException(501, "Agent runtime not yet implemented")
+
+    _sessions[response.sessionId] = response
+    return response
+
+
+@router.get("/sessions", response_model=AgentSessionListResponse)
+def list_sessions() -> AgentSessionListResponse:
+    """List all agent sessions."""
+    sessions = list(_sessions.values())
+    return AgentSessionListResponse(sessions=sessions, total=len(sessions))
+
+
+@router.get("/sessions/{session_id}", response_model=AgentSessionResponse)
+def get_session(session_id: str) -> AgentSessionResponse:
+    """Get a specific agent session."""
+    session = _sessions.get(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail=f"Session {session_id} not found")
+    return session
+
+
+@router.get("/sessions/{session_id}/events")
+async def stream_events(session_id: str) -> StreamingResponse:
+    """Stream agent session events via Server-Sent Events."""
+    session = _sessions.get(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail=f"Session {session_id} not found")
+
+    async def generate() -> AsyncGenerator[str, None]:
+        for event in session.events:
+            data = json.dumps(event.model_dump())
+            yield f"data: {data}\n\n"
+        if session.status != "running":
+            yield 'data: {"type": "done"}\n\n'
+            return
+        yield 'data: {"type": "waiting"}\n\n'
+
+    return StreamingResponse(
+        generate(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
+@router.post("/sessions/{session_id}/approve")
+def respond_approval(
+    session_id: str,
+    request: ApprovalRespondRequest,
+) -> dict:
+    """Respond to a human-in-the-loop approval request."""
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail=f"Session {session_id} not found")
+    return {"request_id": request.request_id, "approved": request.approved, "applied": True}
diff --git a/src/molexp/server/routes/execution.py b/src/molexp/server/routes/execution.py
index 1a3a41b4..a9676bd4 100644
--- a/src/molexp/server/routes/execution.py
+++ b/src/molexp/server/routes/execution.py
@@ -2,18 +2,16 @@
 
 from __future__ import annotations
 
-import json
+from pathlib import Path
 
 from fastapi import APIRouter, Depends
-from pydantic import BaseModel
+from fastapi.responses import JSONResponse
 
-from molexp.workflow import Workflow
-from molexp.workflow.compiler import WorkflowCompiler
+from molexp.workflow.cache import Caching
 
 from ..dependencies import get_workspace
 from ..exceptions import ExperimentNotFoundError, ProjectNotFoundError
-from ..schemas import (ExecutionCreateRequest, ExecutionPlanRequest,
-                       ExecutionPlanResponse, RunResponse)
+from ..schemas import CacheClearResponse, CacheStatsResponse, ExecutionCreateRequest, RunResponse
 
 router = APIRouter(prefix="", tags=["execution"])
 
@@ -32,24 +30,47 @@ def create_execution(
     if not experiment:
         raise ExperimentNotFoundError(request.project_id, request.experiment_id)
 
-    # Create run
-    new_run = experiment.create_run(parameters=request.parameters)
+    new_run = experiment.run(parameters=request.parameters)
+    return RunResponse.from_model(new_run)
 
-    # TODO: Persist workflow_json if supported by Run model
-    # workflow_snapshot = request.workflow_json
 
-    return RunResponse.from_model(new_run)
+@router.post("/plan")
+def get_execution_plan() -> JSONResponse:
+    """Get execution plan for a workflow (not yet implemented)."""
+    return JSONResponse(
+        status_code=501,
+        content={"error": "not_implemented", "message": "Execution planning not yet implemented."},
+    )
 
 
-@router.post("/plan", response_model=ExecutionPlanResponse)
-def get_execution_plan(request: ExecutionPlanRequest) -> ExecutionPlanResponse:
-    """Get execution plan for a workflow definition."""
-    workflow = Workflow.model_validate_json(request.workflow_json)
-    compiler = WorkflowCompiler()
-    compiled_workflow = compiler.compile(workflow)
-    plan = compiled_workflow.get_execution_plan(targets=request.targets)
+# ============================================================================
+# Cache Routes
+# ============================================================================
 
-    return ExecutionPlanResponse(
-        plan=plan,
-        nodeCount=len(plan),
-    )
+# Process-local cache — NOT shared across workers.  Use --workers 1.
+_cache_instance = None
+
+
+def _get_cache():
+    global _cache_instance
+    if _cache_instance is None:
+        store_dir = Path.home() / ".molexp" / "cache"
+        _cache_instance = Caching(store_dir=store_dir)
+        _cache_instance.initialize()
+    return _cache_instance
+
+
+@router.get("/cache/stats", response_model=CacheStatsResponse)
+def get_cache_stats() -> CacheStatsResponse:
+    cache = _get_cache()
+    entry_count = 0
+    if cache._store_dir.exists():
+        entry_count = len(list(cache._store_dir.glob("*.json")))
+    return CacheStatsResponse(storeDir=str(cache._store_dir), entryCount=entry_count)
+
+
+@router.delete("/cache", response_model=CacheClearResponse)
+def clear_cache() -> CacheClearResponse:
+    cache = _get_cache()
+    removed = cache.clear()
+    return CacheClearResponse(removedCount=removed)
diff --git a/src/molexp/server/routes/experiment.py b/src/molexp/server/routes/experiment.py
index caa80c99..a9188c0c 100644
--- a/src/molexp/server/routes/experiment.py
+++ b/src/molexp/server/routes/experiment.py
@@ -2,12 +2,13 @@
 
 from __future__ import annotations
 
+from shutil import rmtree
+
 from fastapi import APIRouter, Depends
 
 from ..dependencies import get_workspace
-from ..exceptions import ExperimentNotFoundError
-from ..schemas import (ExperimentCreateRequest, ExperimentResponse,
-                       MessageResponse)
+from ..exceptions import ExperimentNotFoundError, ProjectNotFoundError
+from ..schemas import ExperimentCreateRequest, ExperimentResponse, MessageResponse
 
 router = APIRouter(
     prefix="/projects/{project_id}/experiments", tags=["experiments"]
@@ -19,13 +20,10 @@ def list_experiments(
     project_id: str,
     workspace=Depends(get_workspace),
 ) -> list[ExperimentResponse]:
-    """List experiments in a project."""
     project = workspace.get_project(project_id)
     if not project:
-        raise ExperimentNotFoundError(project_id, "")
-        
-    experiments = project.list_experiments()
-    return [ExperimentResponse.from_model(e) for e in experiments]
+        raise ProjectNotFoundError(project_id)
+    return [ExperimentResponse.from_model(e) for e in project.list_experiments()]
 
 
 @router.get("/{experiment_id}", response_model=ExperimentResponse)
@@ -34,38 +32,30 @@ def get_experiment(
     experiment_id: str,
     workspace=Depends(get_workspace),
 ) -> ExperimentResponse:
-    """Get experiment details."""
     project = workspace.get_project(project_id)
     if not project:
-        raise ExperimentNotFoundError(project_id, experiment_id)
-
+        raise ProjectNotFoundError(project_id)
     experiment = project.get_experiment(experiment_id)
     if not experiment:
         raise ExperimentNotFoundError(project_id, experiment_id)
-
-    runs = experiment.list_runs()
-    return ExperimentResponse.from_model(experiment, runs=runs)
+    return ExperimentResponse.from_model(experiment, runs=experiment.list_runs())
 
 
 @router.post("", response_model=ExperimentResponse, status_code=201)
 def create_experiment(
     project_id: str,
-    experiment: ExperimentCreateRequest,
+    req: ExperimentCreateRequest,
     workspace=Depends(get_workspace),
 ) -> ExperimentResponse:
-    """Create a new experiment."""
     project = workspace.get_project(project_id)
     if not project:
-        raise ExperimentNotFoundError(project_id, "")
-
-    # Project.create_experiment only takes name
-    new_exp = project.create_experiment(name=experiment.name)
-    
-    # Metadata updates for other fields could happen here if needed
-    # new_exp.metadata.description = experiment.description
-    # new_exp.save()
-    
-    return ExperimentResponse.from_model(new_exp)
+        raise ProjectNotFoundError(project_id)
+    exp = project.experiment(
+        name=req.name,
+        workflow_source=req.workflow_source,
+        params=req.parameter_space,
+    )
+    return ExperimentResponse.from_model(exp)
 
 
 @router.delete("/{experiment_id}", response_model=MessageResponse)
@@ -74,16 +64,11 @@ def delete_experiment(
     experiment_id: str,
     workspace=Depends(get_workspace),
 ) -> MessageResponse:
-    """Delete an experiment."""
-    from shutil import rmtree
-    
     project = workspace.get_project(project_id)
     if not project:
+        raise ProjectNotFoundError(project_id)
+    experiment = project.get_experiment(experiment_id)
+    if not experiment:
         raise ExperimentNotFoundError(project_id, experiment_id)
-        
-    experiment_dir = project.workspace.root / "projects" / project.id / "experiments" / experiment_id
-    if not experiment_dir.exists():
-         raise ExperimentNotFoundError(project_id, experiment_id)
-         
-    rmtree(experiment_dir)
+    rmtree(experiment.experiment_dir)
     return MessageResponse(message="Experiment deleted")
diff --git a/src/molexp/server/routes/project.py b/src/molexp/server/routes/project.py
index d479e063..68d3d7c7 100644
--- a/src/molexp/server/routes/project.py
+++ b/src/molexp/server/routes/project.py
@@ -23,20 +23,17 @@
 
 @router.get("", response_model=list[ProjectResponse])
 def list_projects(workspace=Depends(get_workspace)) -> list[ProjectResponse]:
-    """List all projects."""
-    projects = workspace.list_projects()
-    return [ProjectResponse.from_model(p) for p in projects]
+    return [ProjectResponse.from_model(p) for p in workspace.list_projects()]
 
 
 @router.get("/{id}", response_model=ProjectResponse)
 def get_project(id: str, workspace=Depends(get_workspace)) -> ProjectResponse:
-    """Get project details."""
     project = workspace.get_project(id)
     if not project:
         raise ProjectNotFoundError(id)
-
-    experiments = project.list_experiments()
-    return ProjectResponse.from_model(project, experiment_count=len(experiments))
+    return ProjectResponse.from_model(
+        project, experiment_count=len(project.list_experiments())
+    )
 
 
 @router.post("", response_model=ProjectResponse, status_code=201)
@@ -44,62 +41,42 @@ def create_project(
     project: ProjectCreateRequest,
     workspace=Depends(get_workspace),
 ) -> ProjectResponse:
-    """Create a new project."""
-    new_project = workspace.create_project(
-        name=project.name,
-    )
+    new_project = workspace.project(project.name)
     return ProjectResponse.from_model(new_project)
 
 
 @router.delete("/{id}", response_model=MessageResponse)
-def delete_project(
-    id: str,
-    workspace=Depends(get_workspace),
-) -> MessageResponse:
-    """Delete a project."""
+def delete_project(id: str, workspace=Depends(get_workspace)) -> MessageResponse:
     try:
         workspace.delete_project(id)
     except KeyError:
         raise ProjectNotFoundError(id)
-
     return MessageResponse(message="Project deleted")
 
 
-# ============================================================================
-# Project Asset Routes
-# ============================================================================
+# ── Project Assets ──────────────────────────────────────────────────────────
 
 
 @router.get("/{id}/assets", response_model=list[AssetResponse])
 def list_project_assets(
-    id: str,
-    limit: int = 100,
-    workspace=Depends(get_workspace),
+    id: str, limit: int = 100, workspace=Depends(get_workspace)
 ) -> list[AssetResponse]:
-    """List assets in a project."""
     project = workspace.get_project(id)
     if not project:
         raise ProjectNotFoundError(id)
-
-    assets = project.assets.list_assets()[:limit]
-    return [AssetResponse.from_model(a) for a in assets]
+    return [AssetResponse.from_model(a) for a in project.assets.list_assets()[:limit]]
 
 
 @router.get("/{id}/assets/{asset_id}", response_model=AssetResponse)
 def get_project_asset(
-    id: str,
-    asset_id: str,
-    workspace=Depends(get_workspace),
+    id: str, asset_id: str, workspace=Depends(get_workspace)
 ) -> AssetResponse:
-    """Get project asset details."""
     project = workspace.get_project(id)
     if not project:
         raise ProjectNotFoundError(id)
-
-    asset = project.assets.get(asset_id)
+    asset = project.assets.get_asset(asset_id)
     if not asset:
         raise AssetNotFoundError(asset_id)
-
     return AssetResponse.from_model(asset)
 
 
@@ -109,55 +86,23 @@ async def upload_project_asset(
     file: UploadFile = File(...),
     workspace=Depends(get_workspace),
 ) -> AssetResponse:
-    """Upload a new asset to a project."""
     project = workspace.get_project(id)
     if not project:
         raise ProjectNotFoundError(id)
 
-    # Create temp file
     with tempfile.NamedTemporaryFile(delete=False) as tmp:
         shutil.copyfileobj(file.file, tmp)
         tmp_path = Path(tmp.name)
 
     try:
         filename = file.filename or "untitled"
-
-        # Use project.assets (AssetLibrary) to import
-        asset = project.assets.import_asset(
-            path=tmp_path,
-            name=filename,
-            metadata={"original_filename": filename},
-            action="move",
-        )
-        
-        # Explicitly save project metadata to ensure asset is registered
-        # (Though import_asset in project.py wrapper handles this, but let's be sure we are using the wrapper if it exists)
-        # Wait, I am accessing project.assets (AssetLibrary) directly. 
-        # Project.py wrapper `import_asset` does extra step: self.save().
-        # So I should loop back to using `project.import_asset` if it supports path?
-        # project.py: import_asset(self, name: str, src: str | Path, ...)
-        
-        # NO, I should use project.import_asset because it updates project.json!
-        # Re-doing the call below to use project.import_asset instead of project.assets.import_asset
-        
-        # But wait, project.py: `import_asset` calls `self.assets.import_asset`.
-        # So using project.import_asset is safer.
-        pass
-
-    except Exception:
-        if tmp_path.exists():
-            tmp_path.unlink()
-        raise
-
-    # Re-do with correct method
-    try:
-         asset = project.import_asset(
+        asset = project.import_asset(
             name=filename,
             src=tmp_path,
             action="move",
-            meta={"original_filename": filename}
+            meta={"original_filename": filename},
         )
-         return AssetResponse.from_model(asset)
+        return AssetResponse.from_model(asset)
     except Exception:
         if tmp_path.exists():
             tmp_path.unlink()
@@ -166,20 +111,16 @@ async def upload_project_asset(
 
 @router.get("/{id}/assets/{asset_id}/download")
 def download_project_asset(
-    id: str,
-    asset_id: str,
-    workspace=Depends(get_workspace),
+    id: str, asset_id: str, workspace=Depends(get_workspace)
 ):
-    """Download project asset content."""
     project = workspace.get_project(id)
     if not project:
         raise ProjectNotFoundError(id)
-
-    asset = project.assets.get(asset_id)
+    asset = project.assets.get_asset(asset_id)
     if not asset:
         raise AssetNotFoundError(asset_id)
 
-    payload_dir = project.assets.get_payload_dir(asset_id)
+    payload_dir = asset.path
     if not payload_dir.exists():
         raise AssetNotFoundError(asset_id)
 
@@ -189,7 +130,6 @@ def download_project_asset(
 
     file_path = files[0]
     filename = asset.metadata.get("original_filename") or file_path.name
-
     return StreamingResponse(
         open(file_path, "rb"),
         media_type="application/octet-stream",
diff --git a/src/molexp/server/routes/registry.py b/src/molexp/server/routes/registry.py
index 5cea3a80..dd0fb6c0 100644
--- a/src/molexp/server/routes/registry.py
+++ b/src/molexp/server/routes/registry.py
@@ -1,41 +1,44 @@
-"""Task plugin routes for MolExp API."""
+"""Task plugin routes for MolExp API.
+
+Note: Task registry is being re-implemented as part of Phase 3.
+"""
 
 from __future__ import annotations
 
 from fastapi import APIRouter
+from fastapi.responses import JSONResponse
 
-from molexp.workflow.plugin import get_task_registry
-
-from ..exceptions import TaskNotFoundError
-
-router = APIRouter(prefix="/tasks", tags=["tasks"])
-
+from molexp.plugins import discover_ui_plugins
 
-@router.get("")
-def list_nodes():
-    """List all available node types from plugins.
+from ..schemas import UiPluginListResponse, UiPluginResponse
 
-    Returns:
-        Dictionary with all node definitions including metadata and config schemas
-    """
-    registry = get_task_registry()
-    return registry.to_dict()
+router = APIRouter(tags=["registry"])
 
 
-@router.get("/{node_id}")
-def get_node(node_id: str):
-    """Get details for a specific node type.
+@router.get("/tasks")
+def list_nodes() -> JSONResponse:
+    return JSONResponse(
+        status_code=501,
+        content={
+            "error": "not_implemented",
+            "message": "Task registry is being re-implemented in Phase 3.",
+            "tasks": [],
+        },
+    )
 
-    Args:
-        node_id: Task identifier (e.g., "io.write_file")
 
-    Returns:
-        Task definition with metadata and config schema
-    """
-    registry = get_task_registry()
-    registration = registry.get(node_id)
+@router.get("/tasks/{node_id}")
+def get_node(node_id: str) -> JSONResponse:
+    return JSONResponse(
+        status_code=501,
+        content={
+            "error": "not_implemented",
+            "message": f"Task registry is being re-implemented in Phase 3. Task '{node_id}' not found.",
+        },
+    )
 
-    if not registration:
-        raise TaskNotFoundError(node_id)
 
-    return registration.to_dict()
+@router.get("/plugins", response_model=UiPluginListResponse, tags=["plugins"])
+def list_plugins() -> UiPluginListResponse:
+    plugins = [UiPluginResponse.from_descriptor(plugin) for plugin in discover_ui_plugins()]
+    return UiPluginListResponse(plugins=plugins, total=len(plugins))
diff --git a/src/molexp/server/routes/run.py b/src/molexp/server/routes/run.py
index 7828c2c5..0316ce70 100644
--- a/src/molexp/server/routes/run.py
+++ b/src/molexp/server/routes/run.py
@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import json
 from datetime import datetime
+from pathlib import Path
 
 from fastapi import APIRouter, Depends
 
@@ -10,8 +12,14 @@
 
 from ..dependencies import get_workspace
 from ..exceptions import InvalidStatusError, RunNotFoundError
-from ..schemas import (RunCreateRequest, RunResponse,
-                       RunStatusResponse)
+from ..schemas import (
+    RunCreateRequest,
+    RunExecutionResponse,
+    RunLogsResponse,
+    RunResponse,
+    RunStatusResponse,
+    WorkflowStepInfo,
+)
 
 router = APIRouter(
     prefix="/projects/{project_id}/experiments/{experiment_id}/runs",
@@ -32,13 +40,10 @@ def list_runs(
     experiment_id: str,
     workspace=Depends(get_workspace),
 ) -> list[RunResponse]:
-    """List runs in an experiment."""
     experiment = _get_experiment(workspace, project_id, experiment_id)
     if not experiment:
         raise RunNotFoundError(project_id, experiment_id, "")
-        
-    runs = experiment.list_runs()
-    return [RunResponse.from_model(r) for r in runs]
+    return [RunResponse.from_model(r) for r in experiment.list_runs()]
 
 
 @router.get("/{run_id}", response_model=RunResponse)
@@ -48,15 +53,12 @@ def get_run(
     run_id: str,
     workspace=Depends(get_workspace),
 ) -> RunResponse:
-    """Get run details."""
     experiment = _get_experiment(workspace, project_id, experiment_id)
     if not experiment:
         raise RunNotFoundError(project_id, experiment_id, run_id)
-        
     run = experiment.get_run(run_id)
     if not run:
-         raise RunNotFoundError(project_id, experiment_id, run_id)
-
+        raise RunNotFoundError(project_id, experiment_id, run_id)
     return RunResponse.from_model(run)
 
 
@@ -67,74 +69,118 @@ def create_run(
     run_req: RunCreateRequest,
     workspace=Depends(get_workspace),
 ) -> RunResponse:
-    """Create a new run."""
     experiment = _get_experiment(workspace, project_id, experiment_id)
     if not experiment:
         raise RunNotFoundError(project_id, experiment_id, "")
-
-    new_run = experiment.create_run(parameters=run_req.parameters)
-    return RunResponse.from_model(new_run)
+    run = experiment.run(parameters=run_req.parameters)
+    return RunResponse.from_model(run)
 
 
-@router.patch("/{run_id}/status", response_model=RunStatusResponse)
-def update_run_status(
+@router.get("/{run_id}/logs", response_model=RunLogsResponse)
+def get_run_logs(
     project_id: str,
     experiment_id: str,
     run_id: str,
-    status: dict[str, str],
     workspace=Depends(get_workspace),
-) -> RunStatusResponse:
-    """Update run status."""
+) -> RunLogsResponse:
+    """Return stdout (job.out) and stderr (job.err) for a run."""
     experiment = _get_experiment(workspace, project_id, experiment_id)
     if not experiment:
         raise RunNotFoundError(project_id, experiment_id, run_id)
-        
     run = experiment.get_run(run_id)
     if not run:
         raise RunNotFoundError(project_id, experiment_id, run_id)
 
-    new_status_str = status.get("status", run.status)
-    try:
-        new_status = RunStatus(new_status_str)
-    except ValueError:
-        raise InvalidStatusError(run.status, new_status_str)
+    run_dir: Path = run.run_dir
+    stdout: str | None = None
+    stderr: str | None = None
 
-    run.status = new_status
-    if new_status_str in ["succeeded", "failed", "cancelled"]:
-        run.finished_at = datetime.now()
+    job_out = run_dir / "job.out"
+    if job_out.exists():
+        stdout = job_out.read_text(errors="replace")
 
-    run.save()
+    job_err = run_dir / "job.err"
+    if job_err.exists():
+        stderr = job_err.read_text(errors="replace")
 
-    return RunStatusResponse(
-        id=run.id,
-        status=run.status,
-        finished=run.metadata.updated_at.isoformat(),
+    return RunLogsResponse(stdout=stdout, stderr=stderr)
+
+
+@router.get("/{run_id}/execution", response_model=RunExecutionResponse)
+def get_run_execution(
+    project_id: str,
+    experiment_id: str,
+    run_id: str,
+    workspace=Depends(get_workspace),
+) -> RunExecutionResponse:
+    """Return workflow execution state from workflow.json."""
+    experiment = _get_experiment(workspace, project_id, experiment_id)
+    if not experiment:
+        raise RunNotFoundError(project_id, experiment_id, run_id)
+    run = experiment.get_run(run_id)
+    if not run:
+        raise RunNotFoundError(project_id, experiment_id, run_id)
+
+    exec_root: Path = run.run_dir / "execution"
+    if not exec_root.exists():
+        return RunExecutionResponse()
+
+    exec_dirs = sorted(p for p in exec_root.iterdir() if p.is_dir())
+    if not exec_dirs:
+        return RunExecutionResponse()
+
+    # Latest execution is the last one alphabetically (exec-id, exec-id-2, exec-id-3…)
+    latest = exec_dirs[-1]
+    wf_file = latest / "workflow.json"
+    if not wf_file.exists():
+        return RunExecutionResponse(execution_id=latest.name)
+
+    data = json.loads(wf_file.read_text())
+    steps = [
+        WorkflowStepInfo(
+            index=s["index"],
+            status=s.get("status", "pending"),
+            step_outputs=s.get("step_outputs", {}),
+        )
+        for s in data.get("steps", [])
+    ]
+    return RunExecutionResponse(
+        execution_id=data.get("execution_id", latest.name),
+        status=data.get("status", "running"),
+        steps=steps,
+        end=data.get("end"),
     )
 
 
-@router.post("/{run_id}/start", response_model=RunStatusResponse)
-def start_run(
+@router.patch("/{run_id}/status", response_model=RunStatusResponse)
+def update_run_status(
     project_id: str,
     experiment_id: str,
     run_id: str,
+    status: dict[str, str],
     workspace=Depends(get_workspace),
 ) -> RunStatusResponse:
-    """Start run execution."""
     experiment = _get_experiment(workspace, project_id, experiment_id)
     if not experiment:
         raise RunNotFoundError(project_id, experiment_id, run_id)
-        
     run = experiment.get_run(run_id)
     if not run:
         raise RunNotFoundError(project_id, experiment_id, run_id)
 
-    # Minimal start logic for now
-    with run.context() as ctx:
-        # Mock execution or async dispatch
-        pass
-        
+    new_status_str = status.get("status", run.status)
+    try:
+        new_status = RunStatus(new_status_str)
+    except ValueError:
+        raise InvalidStatusError(run.status, new_status_str)
+
+    updates: dict = {"status": new_status.value}
+    if new_status_str in ("succeeded", "failed", "cancelled"):
+        updates["finished_at"] = datetime.now()
+
+    run._update_metadata(**updates)
+
     return RunStatusResponse(
         id=run.id,
         status=run.status,
-        finished=None,
+        finished=run.metadata.finished_at.isoformat() if run.metadata.finished_at else None,
     )
diff --git a/src/molexp/server/routes/workspace.py b/src/molexp/server/routes/workspace.py
index 742cda24..ad0c51d7 100644
--- a/src/molexp/server/routes/workspace.py
+++ b/src/molexp/server/routes/workspace.py
@@ -2,22 +2,33 @@
 
 from __future__ import annotations
 
-from pathlib import Path
-
 import mimetypes
+from pathlib import Path
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from molexp.workspace import Workspace
 
 from ..dependencies import get_workspace, set_workspace_path_override
 from ..schemas import (
-    DirectoryCreateRequest,
-    FileContentUpdateRequest,
     FileContentResponse,
     WorkspaceInfoResponse,
     WorkspaceOpenRequest,
 )
 
+
+class DirectoryCreateRequest(BaseModel):
+    folder_id: str = Field(..., description="Workspace folder ID or 'workspace'")
+    path: str = Field(..., description="Relative path for new directory")
+
+
+class FileContentUpdateRequest(BaseModel):
+    folder_id: str = Field(..., description="Workspace folder ID or 'workspace'")
+    path: str = Field(..., description="Relative path within the folder")
+    content: str = Field(..., description="New file content")
+
 router = APIRouter(prefix="/workspace", tags=["workspace"])
 
 MAX_TEXT_BYTES = 2_000_000
@@ -126,8 +137,6 @@ def open_workspace(
         path.mkdir(parents=True, exist_ok=True)
 
     set_workspace_path_override(path)
-    from molexp.workspace import Workspace
-
     workspace = Workspace.from_path(path)
     return WorkspaceInfoResponse(
         root=str(workspace.root),
diff --git a/src/molexp/server/schemas/__init__.py b/src/molexp/server/schemas/__init__.py
index 276a9bab..4131ab48 100644
--- a/src/molexp/server/schemas/__init__.py
+++ b/src/molexp/server/schemas/__init__.py
@@ -1,57 +1,83 @@
 """API Schemas package."""
 
-from .requests import (AssetUpdateRequest, DirectoryCreateRequest,
-                       ExecutionPlanRequest, ExecutionCreateRequest, ExperimentCreateRequest,
-                       ExperimentUpdateRequest, FileContentUpdateRequest,
-                       GenericExecutionRequest, ProjectCreateRequest,
-                       ProjectUpdateRequest, RunCreateRequest,
-                       RunStatusUpdateRequest, WorkspaceFolderAddRequest,
-                       WorkspaceOpenRequest)
-from .responses import (AssetResponse, DashboardStatsResponse,
-                        EntityClassificationResponse, ExecutionPlanResponse,
-                        ExperimentResponse, FileContentResponse,
-                        FolderBrowseResponse, FolderEntryResponse,
-                        HealthResponse, MessageResponse, NodeListResponse,
-                        NodeResponse, ProjectListResponse, ProjectResponse,
-                        RunResponse, RunStatusResponse, RunSummary,
-                        WorkspaceFolderResponse, WorkspaceInfoResponse,
-                        WorkspaceScanResponse)
+from .requests import (
+    ApprovalRespondRequest,
+    AssetUpdateRequest,
+    ExecutionCreateRequest,
+    ExperimentCreateRequest,
+    GoalCreateRequest,
+    ProjectCreateRequest,
+    ProjectUpdateRequest,
+    RunCreateRequest,
+    RunStatusUpdateRequest,
+    WorkspaceOpenRequest,
+)
+from .responses import (
+    AgentSessionListResponse,
+    AgentSessionResponse,
+    AssetResponse,
+    CacheClearResponse,
+    CacheStatsResponse,
+    ExecutionPlanResponse,
+    ExperimentResponse,
+    FileContentResponse,
+    FolderBrowseResponse,
+    FolderEntryResponse,
+    HealthResponse,
+    MessageResponse,
+    ProjectListResponse,
+    ProjectResponse,
+    RunExecutionResponse,
+    RunLogsResponse,
+    RunResponse,
+    RunStatusResponse,
+    RunSummary,
+    SessionEventResponse,
+    UiPluginListResponse,
+    UiPluginResponse,
+    WorkflowSnapshotResponse,
+    WorkflowStepInfo,
+    WorkspaceFolderResponse,
+    WorkspaceInfoResponse,
+)
 
 __all__ = [
     # Requests
-    "WorkspaceFolderAddRequest",
-    "WorkspaceOpenRequest",
-    "FileContentUpdateRequest",
-    "DirectoryCreateRequest",
+    "ApprovalRespondRequest",
+    "AssetUpdateRequest",
+    "ExecutionCreateRequest",
+    "ExperimentCreateRequest",
+    "GoalCreateRequest",
     "ProjectCreateRequest",
     "ProjectUpdateRequest",
-    "ExperimentCreateRequest",
-    "ExperimentUpdateRequest",
     "RunCreateRequest",
     "RunStatusUpdateRequest",
-    "GenericExecutionRequest",
-    "ExecutionCreateRequest",
-    "ExecutionPlanRequest",
-    "AssetUpdateRequest",
+    "WorkspaceOpenRequest",
     # Responses
-    "ProjectResponse",
-    "ProjectListResponse",
-    "ExperimentResponse",
-    "RunResponse",
-    "RunSummary",
-    "RunStatusResponse",
+    "AgentSessionListResponse",
+    "AgentSessionResponse",
     "AssetResponse",
-    "WorkspaceInfoResponse",
-    "DashboardStatsResponse",
+    "CacheClearResponse",
+    "CacheStatsResponse",
+    "ExecutionPlanResponse",
+    "ExperimentResponse",
+    "FileContentResponse",
     "FolderBrowseResponse",
     "FolderEntryResponse",
-    "WorkspaceFolderResponse",
-    "FileContentResponse",
-    "ExecutionPlanResponse",
-    "NodeResponse",
-    "NodeListResponse",
-    "MessageResponse",
     "HealthResponse",
-    "EntityClassificationResponse",
-    "WorkspaceScanResponse",
+    "MessageResponse",
+    "ProjectListResponse",
+    "ProjectResponse",
+    "RunExecutionResponse",
+    "RunLogsResponse",
+    "RunResponse",
+    "RunStatusResponse",
+    "RunSummary",
+    "WorkflowStepInfo",
+    "SessionEventResponse",
+    "UiPluginListResponse",
+    "UiPluginResponse",
+    "WorkflowSnapshotResponse",
+    "WorkspaceFolderResponse",
+    "WorkspaceInfoResponse",
 ]
diff --git a/src/molexp/server/schemas/requests.py b/src/molexp/server/schemas/requests.py
index efc59f1e..e42fc758 100644
--- a/src/molexp/server/schemas/requests.py
+++ b/src/molexp/server/schemas/requests.py
@@ -1,10 +1,6 @@
 """Pydantic request models for MolExp API.
 
-This module defines standardized request models used across all API endpoints.
-Consolidating request models provides:
-- Single source of truth for request validation
-- Consistent naming conventions
-- Better API documentation
+Aligned with workspace.models — field names match domain models.
 """
 
 from __future__ import annotations
@@ -13,62 +9,18 @@
 
 from pydantic import BaseModel, Field
 
-# ============================================================================
-# Workspace Requests
-# ============================================================================
-
-
-class WorkspaceFolderAddRequest(BaseModel):
-    """Request to add a workspace folder."""
-
-    path: str = Field(..., description="Absolute path to the folder")
-    name: str | None = Field(None, description="Display name (defaults to folder name)")
+# ── Workspace ───────────────────────────────────────────────────────────────
 
 
 class WorkspaceOpenRequest(BaseModel):
-    """Request to open a workspace path."""
-
     path: str = Field(..., description="Absolute path to the workspace")
-    create_if_missing: bool = Field(
-        False, description="Create workspace metadata if missing"
-    )
-
-
-# ============================================================================
-# File Requests
-# ============================================================================
-
-
-class FileContentUpdateRequest(BaseModel):
-    """Request to update file content."""
-
-    folder_id: str = Field(..., description="Workspace folder ID or 'workspace'")
-    path: str = Field(..., description="Relative path within the folder")
-    content: str = Field(..., description="New file content")
+    create_if_missing: bool = Field(False, description="Create if missing")
 
 
-class DirectoryCreateRequest(BaseModel):
-    """Request to create a directory."""
-
-    folder_id: str = Field(..., description="Workspace folder ID or 'workspace'")
-    path: str = Field(..., description="Relative path for new directory")
-
-
-# ============================================================================
-# Project Requests
-# ============================================================================
+# ── Project ─────────────────────────────────────────────────────────────────
 
 
 class ProjectCreateRequest(BaseModel):
-    """Request to create a project."""
-
-    id: str = Field(
-        ...,
-        description="Unique project identifier (slug)",
-        min_length=3,
-        max_length=50,
-        pattern=r"^[a-z0-9-]+$",
-    )
     name: str = Field(..., description="Human-readable project name")
     description: str = Field("", description="Project description")
     owner: str = Field("", description="Project owner")
@@ -76,8 +28,6 @@ class ProjectCreateRequest(BaseModel):
 
 
 class ProjectUpdateRequest(BaseModel):
-    """Request to update a project."""
-
     name: str | None = None
     description: str | None = None
     owner: str | None = None
@@ -85,101 +35,58 @@ class ProjectUpdateRequest(BaseModel):
     config: dict[str, Any] | None = None
 
 
-# ============================================================================
-# Experiment Requests
-# ============================================================================
+# ── Experiment ──────────────────────────────────────────────────────────────
 
 
 class ExperimentCreateRequest(BaseModel):
-    """Request to create an experiment."""
-
-    id: str = Field(
-        ...,
-        description="Unique experiment identifier (slug)",
-        min_length=3,
-        max_length=50,
-        pattern=r"^[a-z0-9-]+$",
-    )
     name: str = Field(..., description="Human-readable experiment name")
-    workflow_source: str = Field(..., description="Path to workflow file")
+    workflow_source: str | None = Field(None, description="Path to workflow file")
     description: str = Field("", description="Experiment description")
     parameter_space: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Parameter space definition",
+        default_factory=dict, description="Parameter space definition"
     )
 
 
-class ExperimentUpdateRequest(BaseModel):
-    """Request to update an experiment."""
-
-    name: str | None = None
-    description: str | None = None
-    parameter_space: dict[str, Any] | None = None
-
-
-# ============================================================================
-# Run Requests
-# ============================================================================
+# ── Run ─────────────────────────────────────────────────────────────────────
 
 
 class RunCreateRequest(BaseModel):
-    """Request to create a run."""
-
     parameters: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Run parameters",
+        default_factory=dict, description="Run parameters"
     )
-    workflow_file: str = Field(..., description="Workflow file path")
-    git_commit: str | None = Field(None, description="Git commit hash")
 
 
 class RunStatusUpdateRequest(BaseModel):
-    """Request to update run status."""
-
     status: str = Field(..., description="New status value")
 
 
-# ============================================================================
-# Execution Requests
-# ============================================================================
-
-
-class GenericExecutionRequest(BaseModel):
-    """Request for generic execution (playground)."""
-
-    name: str | None = Field(None, description="Execution name")
-    workflowSnapshot: dict[str, Any] | None = Field(
-        None,
-        description="Serialized workflow graph",
-    )
+# ── Execution ───────────────────────────────────────────────────────────────
 
 
 class ExecutionCreateRequest(BaseModel):
-    """Request to create a new execution in a specific context."""
-
     workflow_json: dict[str, Any] = Field(..., description="Serialized workflow graph")
-    project_id: str = Field(..., description="Target Project ID")
-    experiment_id: str = Field(..., description="Target Experiment ID")
-    parameters: dict[str, Any] = Field(default_factory=dict, description="Execution parameters")
+    project_id: str = Field(..., description="Target project ID")
+    experiment_id: str = Field(..., description="Target experiment ID")
+    parameters: dict[str, Any] = Field(default_factory=dict)
 
 
-class ExecutionPlanRequest(BaseModel):
-    """Request for execution plan."""
+# ── Asset ───────────────────────────────────────────────────────────────────
 
-    workflow_json: str = Field(..., description="Workflow definition as JSON string")
-    targets: list[str] | None = Field(
-        None,
-        description="Target node IDs (defaults to workflow targets)",
-    )
 
+class AssetUpdateRequest(BaseModel):
+    tags: list[str] | None = None
+    metadata: dict[str, Any] | None = None
 
-# ============================================================================
-# Asset Requests
-# ============================================================================
 
+# ── Agent ───────────────────────────────────────────────────────────────────
 
-class AssetUpdateRequest(BaseModel):
-    """Request to update asset metadata."""
 
-    tags: list[str] | None = None
-    metadata: dict[str, Any] | None = None
+class GoalCreateRequest(BaseModel):
+    description: str = Field(..., description="Natural language goal description")
+    constraints: dict[str, Any] = Field(default_factory=dict)
+    success_criteria: list[str] = Field(default_factory=list)
+
+
+class ApprovalRespondRequest(BaseModel):
+    request_id: str = Field(..., description="Approval request ID")
+    approved: bool = Field(..., description="Whether to approve")
diff --git a/src/molexp/server/schemas/responses.py b/src/molexp/server/schemas/responses.py
index 13a69087..788d7b71 100644
--- a/src/molexp/server/schemas/responses.py
+++ b/src/molexp/server/schemas/responses.py
@@ -1,410 +1,213 @@
 """Pydantic response models for MolExp API.
 
-This module defines standardized response models used across all API endpoints.
-Using explicit models instead of manual dict construction improves:
-- Type safety and IDE support
-- Automatic API documentation (OpenAPI/Swagger)
-- Consistency across endpoints
-- Response validation
+All ``from_model()`` methods take typed domain objects — no ``Any``,
+no ``getattr`` guessing.
 """
 
 from __future__ import annotations
 
-from datetime import datetime
 from typing import Any
 
 from pydantic import BaseModel, Field
 
-# ============================================================================
-# Base Models
-# ============================================================================
+from molexp.workspace import (
+    Asset,
+    Experiment,
+    Project,
+    Run,
+)
 
+# ── Project ─────────────────────────────────────────────────────────────────
 
-class TimestampMixin(BaseModel):
-    """Mixin for models with timestamps."""
-
-    created: str = Field(..., description="ISO 8601 creation timestamp")
-
-
-class EntityMixin(BaseModel):
-    """Mixin for entity models with an ID."""
 
+class ProjectResponse(BaseModel):
     id: str
-
-
-# ============================================================================
-# Project Responses
-# ============================================================================
-
-
-class ProjectResponse(EntityMixin, TimestampMixin):
-    """Project response model."""
-
-    projectId: str
     name: str
     description: str = ""
     owner: str = ""
     tags: list[str] = Field(default_factory=list)
     config: dict[str, Any] = Field(default_factory=dict)
+    created: str
     experimentCount: int | None = None
 
     @classmethod
-    def from_model(
-        cls, project: Any, experiment_count: int | None = None
-    ) -> "ProjectResponse":
-        """Create response from Project model."""
+    def from_model(cls, project: Project, experiment_count: int | None = None) -> ProjectResponse:
         return cls(
             id=project.id,
-            projectId=project.id,
             name=project.name,
-            description=getattr(project, "description", ""),
-            owner=getattr(project, "owner", ""),
-            tags=getattr(project, "tags", []),
+            description=project.description,
+            owner=project.owner,
+            tags=project.tags,
+            config=project.config,
             created=project.created_at.isoformat(),
-            config=getattr(project, "config", {}),
             experimentCount=experiment_count,
         )
 
 
 class ProjectListResponse(BaseModel):
-    """List of projects."""
-
     projects: list[ProjectResponse]
     total: int
 
 
-class ExperimentSummary(EntityMixin, TimestampMixin):
-    """Experiment summary for nested responses."""
-
-    name: str
-
-
-# ============================================================================
-# Experiment Responses
-# ============================================================================
+# ── Experiment ──────────────────────────────────────────────────────────────
 
 
-class ExperimentResponse(EntityMixin, TimestampMixin):
-    """Experiment response model."""
-
-    experimentId: str
+class ExperimentResponse(BaseModel):
+    id: str
     projectId: str
     name: str
     description: str = ""
-    workflow: str = Field(..., description="Workflow source path")
+    workflow: str | None = None
     workflowType: str | None = None
     gitCommit: str | None = None
     parameterSpace: dict[str, Any] = Field(default_factory=dict)
-    defaultInputs: list[dict[str, Any]] = Field(default_factory=list)
+    created: str
     runCount: int | None = None
     runs: list["RunSummary"] = Field(default_factory=list)
 
     @classmethod
     def from_model(
-        cls,
-        experiment: Any,
-        runs: list[Any] | None = None,
-    ) -> "ExperimentResponse":
-        """Create response from Experiment model."""
+        cls, experiment: Experiment, runs: list[Run] | None = None
+    ) -> ExperimentResponse:
         run_list = []
         if runs:
             run_list = [
                 RunSummary(
                     id=r.id,
-                    status=getattr(r.status, "value", r.status),
-                    created=getattr(r, "created_at", r.metadata.created_at).isoformat(),
-                    parameters=getattr(r, "parameters", r.metadata.parameters),
+                    status=r.status,
+                    created=r.metadata.created_at.isoformat(),
+                    parameters=r.parameters,
                 )
                 for r in runs
             ]
-
-        workflow_template = getattr(experiment, "workflow_template", None)
-
         return cls(
             id=experiment.id,
-            experimentId=experiment.id,
             projectId=experiment.project.id,
             name=experiment.name,
-            description=getattr(experiment, "description", ""),
-            workflow=getattr(workflow_template, "source", ""),
-            workflowType=getattr(workflow_template, "type", None),
-            gitCommit=getattr(workflow_template, "git_commit", None),
+            description=experiment.description,
+            workflow=experiment.metadata.workflow_source,
+            workflowType=experiment.metadata.workflow_type,
+            gitCommit=experiment.metadata.git_commit,
+            parameterSpace=experiment.metadata.parameter_space,
             created=experiment.created_at.isoformat(),
-            parameterSpace=getattr(experiment, "parameter_space", {}),
-            defaultInputs=[
-                {"assetId": ref.asset_id, "role": ref.role}
-                for ref in getattr(experiment, "default_inputs", [])
-            ],
             runCount=len(runs) if runs else None,
             runs=run_list,
         )
 
 
-# ============================================================================
-# Run Responses
-# ============================================================================
-
+# ── Run ─────────────────────────────────────────────────────────────────────
 
-class RunSummary(EntityMixin, TimestampMixin):
-    """Run summary for list responses."""
 
+class RunSummary(BaseModel):
+    id: str
     status: str
+    created: str
     parameters: dict[str, Any] = Field(default_factory=dict)
 
 
 class WorkflowSnapshotResponse(BaseModel):
-    """Workflow snapshot details."""
-
-    file: str
+    source: str
     gitCommit: str | None = None
-    serializedGraph: str | None = None
-
+    codeHash: str | None = None
+    configHash: str | None = None
 
-class AssetRefResponse(BaseModel):
-    """Asset reference response."""
 
-    assetId: str
-    role: str
-    producerRunId: str | None = None
-    accessedAt: str | None = None
-    producedAt: str | None = None
-
-
-class AssetRefsResponse(BaseModel):
-    """Collection of asset references."""
-
-    inputs: list[AssetRefResponse] = Field(default_factory=list)
-    outputs: list[AssetRefResponse] = Field(default_factory=list)
-
-
-class ContextSnapshotResponse(BaseModel):
-    """Execution context snapshot."""
-
-    environment: dict[str, str] = Field(default_factory=dict)
-    dependencies: dict[str, str] = Field(default_factory=dict)
-    hardware: dict[str, Any] = Field(default_factory=dict)
-
-
-class RunResponse(EntityMixin, TimestampMixin):
-    """Full run response model."""
-
-    runId: str
+class RunResponse(BaseModel):
+    id: str
     projectId: str
     experimentId: str
     status: str
+    created: str
     finished: str | None = None
     parameters: dict[str, Any] = Field(default_factory=dict)
     workflow: WorkflowSnapshotResponse | None = None
+    error: dict[str, str] | None = None
     executorInfo: dict[str, Any] = Field(default_factory=dict)
-    workingDir: str | None = None
-    logsDir: str | None = None
-    assetRefs: AssetRefsResponse | None = None
-    context: ContextSnapshotResponse | None = None
+    profile: str | None = None
+    config: dict[str, Any] = Field(default_factory=dict)
+    configHash: str | None = None
 
     @classmethod
-    def from_model(
-        cls,
-        run: Any,
-        asset_refs: Any | None = None,
-        context: Any | None = None,
-    ) -> "RunResponse":
-        """Create response from Run model."""
-        asset_refs_response = None
-        if asset_refs:
-            asset_refs_response = AssetRefsResponse(
-                inputs=[
-                    AssetRefResponse(
-                        assetId=ref.asset_id,
-                        role=ref.role,
-                        producerRunId=ref.producer_id,
-                        accessedAt=(
-                            ref.accessed_at.isoformat() if ref.accessed_at else None
-                        ),
-                    )
-                    for ref in asset_refs.inputs
-                ],
-                outputs=[
-                    AssetRefResponse(
-                        assetId=ref.asset_id,
-                        role=ref.role,
-                        producerRunId=ref.producer_id,
-                        producedAt=(
-                            ref.produced_at.isoformat() if ref.produced_at else None
-                        ),
-                    )
-                    for ref in asset_refs.outputs
-                ],
+    def from_model(cls, run: Run) -> RunResponse:
+        wf_snap = None
+        if run.metadata.workflow_snapshot:
+            s = run.metadata.workflow_snapshot
+            wf_snap = WorkflowSnapshotResponse(
+                source=s.source,
+                gitCommit=s.git_commit,
+                codeHash=s.code_hash,
+                configHash=s.config_hash,
             )
-
-        context_response = None
-        if context:
-            context_response = ContextSnapshotResponse(
-                environment=context.environment,
-                dependencies=context.dependencies,
-                hardware=context.hardware,
-            )
-
+        error = None
+        if run.metadata.error:
+            error = {
+                "type": run.metadata.error.type,
+                "message": run.metadata.error.message,
+            }
         return cls(
             id=run.id,
-            runId=run.id,
             projectId=run.experiment.project.id,
             experimentId=run.experiment.id,
-            status=getattr(run.status, "value", run.status),
-            created=getattr(run, "created_at", run.metadata.created_at).isoformat(),
-            finished=(
-                run.finished_at.isoformat()
-                if getattr(run, "finished_at", None)
-                else (
-                    run.metadata.finished_at.isoformat()
-                    if run.metadata.finished_at
-                    else None
-                )
-            ),
-            parameters=getattr(run, "parameters", run.metadata.parameters),
-            workflow=(
-                WorkflowSnapshotResponse(
-                    file=run.workflow_snapshot.workflow_file,
-                    gitCommit=run.workflow_snapshot.git_commit,
-                    serializedGraph=run.workflow_snapshot.serialized_graph,
-                )
-                if getattr(run, "workflow_snapshot", None)
-                else None
-            ),
-            executorInfo=getattr(run, "executor_info", {}),
-            workingDir=getattr(run, "working_dir", None),
-            logsDir=getattr(run, "logs_dir", None),
-            assetRefs=asset_refs_response,
-            context=context_response,
+            status=run.status,
+            created=run.metadata.created_at.isoformat(),
+            finished=run.metadata.finished_at.isoformat() if run.metadata.finished_at else None,
+            parameters=run.parameters,
+            workflow=wf_snap,
+            error=error,
+            executorInfo=run.metadata.executor_info,
+            profile=run.metadata.profile,
+            config=run.metadata.config,
+            configHash=run.metadata.config_hash,
         )
 
 
-# ============================================================================
-# Asset Responses
-# ============================================================================
-
-
-class AssetFileResponse(BaseModel):
-    """Asset file details."""
+class RunStatusResponse(BaseModel):
+    id: str
+    status: str
+    finished: str | None = None
 
-    path: str
-    size: int
-    hash: str
 
+# ── Asset ───────────────────────────────────────────────────────────────────
 
-class AssetResponse(EntityMixin, TimestampMixin):
-    """Asset response model."""
 
-    assetId: str
-    type: str
-    format: str
-    size: int
-    contentHash: str
-    mimeType: str = ""
-    producerRunId: str | None = None
-    tags: list[str] = Field(default_factory=list)
+class AssetResponse(BaseModel):
+    id: str
+    name: str
+    created: str
     metadata: dict[str, Any] = Field(default_factory=dict)
-    files: list[AssetFileResponse] = Field(default_factory=list)
 
     @classmethod
-    def from_model(cls, asset: Any) -> "AssetResponse":
-        """Create response from Asset model."""
-        def _iter_files(root: Any) -> list[AssetFileResponse]:
-            path = getattr(root, "path", None)
-            if not path:
-                return []
-            try:
-                from pathlib import Path
-
-                base = Path(path)
-            except Exception:
-                return []
-            if not base.exists():
-                return []
-            files: list[AssetFileResponse] = []
-            if base.is_file():
-                files.append(
-                    AssetFileResponse(path=str(base), size=base.stat().st_size, hash="")
-                )
-                return files
-            for item in base.rglob("*"):
-                if item.is_file():
-                    files.append(
-                        AssetFileResponse(path=str(item), size=item.stat().st_size, hash="")
-                    )
-            return files
-
-        def _total_size(file_entries: list[AssetFileResponse]) -> int:
-            return sum(entry.size for entry in file_entries)
-
-        file_entries = (
-            [
-                AssetFileResponse(path=f.path, size=f.size, hash=f.hash)
-                for f in getattr(asset, "files", [])
-            ]
-            if hasattr(asset, "files")
-            else _iter_files(asset)
-        )
-
+    def from_model(cls, asset: Asset) -> AssetResponse:
         return cls(
             id=asset.asset_id,
-            assetId=asset.asset_id,
-            type=getattr(getattr(asset, "type", None), "value", None)
-            or getattr(asset, "type", None)
-            or "asset",
-            format=getattr(asset, "format", None) or "unknown",
-            size=getattr(asset, "size_bytes", None) or _total_size(file_entries),
-            contentHash=getattr(asset, "content_hash", None) or "",
-            mimeType=getattr(asset, "mime_type", None) or "",
+            name=asset.name,
             created=asset.created_at.isoformat(),
-            producerRunId=getattr(asset, "producer_id", None),
-            tags=getattr(asset, "tags", []),
-            metadata=getattr(asset, "metadata", {}),
-            files=file_entries,
+            metadata=asset.metadata,
         )
 
 
-# ============================================================================
-# Workspace Responses
-# ============================================================================
+# ── Workspace ───────────────────────────────────────────────────────────────
 
 
 class WorkspaceInfoResponse(BaseModel):
-    """Workspace info response."""
-
     root: str
     projectCount: int
     assetCount: int
 
 
-class DashboardStatsResponse(BaseModel):
-    """Dashboard statistics response."""
-
-    totalExperiments: int
-    activeWorkflows: int
-    dataUsage: str
-    computeHours: str
-    recentExperiments: list[dict[str, Any]]
-
-
 class FolderEntryResponse(BaseModel):
-    """Folder entry for browsing."""
-
     name: str
     path: str
-    type: str  # "file" or "directory"
+    type: str
     size: int | None = None
 
 
 class FolderBrowseResponse(BaseModel):
-    """Folder browse response."""
-
     path: str
     entries: list[FolderEntryResponse]
 
 
 class WorkspaceFolderResponse(BaseModel):
-    """Workspace folder response."""
-
     id: str
     path: str
     name: str
@@ -412,95 +215,111 @@ class WorkspaceFolderResponse(BaseModel):
 
 
 class FileContentResponse(BaseModel):
-    """File content response."""
-
     content: str
 
 
-# ============================================================================
-# Execution Responses
-# ============================================================================
+# ── Execution ───────────────────────────────────────────────────────────────
 
 
 class ExecutionPlanResponse(BaseModel):
-    """Execution plan response."""
-
     plan: list[str]
     nodeCount: int
 
 
-class RunStatusResponse(BaseModel):
-    """Run status update response."""
+class CacheStatsResponse(BaseModel):
+    storeDir: str
+    entryCount: int
 
-    id: str
-    status: str
-    finished: str | None = None
 
+class CacheClearResponse(BaseModel):
+    removedCount: int
 
-# ============================================================================
-# Task Responses
-# ============================================================================
 
+# ── Agent ───────────────────────────────────────────────────────────────────
 
-class NodePortResponse(BaseModel):
-    """Task port definition."""
 
-    id: str
-    label: str
+class SessionEventResponse(BaseModel):
     type: str
-    required: bool = True
+    ts: str
+    payload: dict[str, Any] = Field(default_factory=dict)
 
 
-class NodeResponse(BaseModel):
-    """Task type response."""
+class AgentSessionResponse(BaseModel):
+    sessionId: str
+    status: str
+    goalDescription: str
+    createdAt: str
+    events: list[SessionEventResponse] = Field(default_factory=list)
+
+
+class AgentSessionListResponse(BaseModel):
+    sessions: list[AgentSessionResponse]
+    total: int
+
+
+# ── Plugin Registry ─────────────────────────────────────────────────────────
 
+
+class UiPluginResponse(BaseModel):
     id: str
-    label: str
-    category: str
-    description: str
-    inputs: list[NodePortResponse]
-    outputs: list[NodePortResponse]
-    icon: str | None = None
-    tags: list[str] = Field(default_factory=list)
-    config_schema: dict[str, Any] = Field(default_factory=dict)
+    title: str
+    description: str = ""
+    uiModule: str | None = None
+    capabilities: list[str] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)
 
+    @classmethod
+    def from_descriptor(cls, descriptor) -> "UiPluginResponse":
+        return cls(
+            id=descriptor.id,
+            title=descriptor.title,
+            description=descriptor.description,
+            uiModule=descriptor.ui_module,
+            capabilities=list(descriptor.capabilities),
+            metadata=descriptor.metadata,
+        )
 
-class NodeListResponse(BaseModel):
-    """List of node types."""
 
-    tasks: list[NodeResponse]
+class UiPluginListResponse(BaseModel):
+    plugins: list[UiPluginResponse]
+    total: int
 
 
-# ============================================================================
-# Generic Responses
-# ============================================================================
+# ── Generic ─────────────────────────────────────────────────────────────────
 
 
 class MessageResponse(BaseModel):
-    """Generic message response."""
-
     message: str
 
 
 class HealthResponse(BaseModel):
-    """Health check response."""
-
     status: str
     workspace_available: bool
-    ir_available: bool
+    capabilities: dict[str, bool] = Field(default_factory=dict)
 
 
-class EntityClassificationResponse(BaseModel):
-    """Entity classification response."""
+# ── Run logs / execution ─────────────────────────────────────────────────────
 
-    indexed: bool
-    kind: str
-    path: str
-    metadata: dict[str, Any] | None = None
 
+class RunLogsResponse(BaseModel):
+    """Contents of job.out and job.err for a run."""
 
-class WorkspaceScanResponse(BaseModel):
-    """Workspace scan response."""
+    stdout: str | None = None
+    stderr: str | None = None
 
-    total: int
-    entities: list[EntityClassificationResponse]
+
+class WorkflowStepInfo(BaseModel):
+    """Human-readable summary of one workflow execution step."""
+
+    index: int
+    status: str  # pending | running | success | error
+    step_outputs: dict[str, Any] = Field(default_factory=dict)
+
+
+class RunExecutionResponse(BaseModel):
+    """Workflow execution state read from workflow.json."""
+
+    execution_id: str | None = None
+    status: str = "not_started"  # running | completed | failed | not_started
+    steps: list[WorkflowStepInfo] = Field(default_factory=list)
+    end: dict[str, Any] | None = None
diff --git a/src/molexp/sweep/__init__.py b/src/molexp/sweep/__init__.py
new file mode 100644
index 00000000..2fa5a3ba
--- /dev/null
+++ b/src/molexp/sweep/__init__.py
@@ -0,0 +1,29 @@
+"""Sweep-level orchestration built on pydantic-graph.
+
+Phase-1 scope: a single-node graph that fans out replicas
+(``experiment × mol_run``) concurrently, bounded by a ``jobs`` semaphore.
+Every replica currently executes *in-process* via
+``experiment.workflow.execute(...)``.
+
+Future phases (see ``docs/spec/unified-pydantic-graph-dispatch.md``):
+
+* **Phase 2** — replace the local-only body with backend-aware dispatch
+  (``local`` / ``slurm`` / ``pbs`` / ``lsf``) routed through molq.
+* **Phase 3** — expose per-node ``backend=`` on inner ``@wf.task``.
+"""
+
+from .graph import (
+    SweepDeps,
+    SweepReplica,
+    SweepRoot,
+    SweepState,
+    run_sweep,
+)
+
+__all__ = [
+    "SweepDeps",
+    "SweepReplica",
+    "SweepRoot",
+    "SweepState",
+    "run_sweep",
+]
diff --git a/src/molexp/sweep/graph.py b/src/molexp/sweep/graph.py
new file mode 100644
index 00000000..c1acadf2
--- /dev/null
+++ b/src/molexp/sweep/graph.py
@@ -0,0 +1,185 @@
+"""Sweep-level pydantic-graph: fan out replicas with bounded concurrency.
+
+Phase-1 design. See ``docs/spec/unified-pydantic-graph-dispatch.md``.
+
+A sweep is the outer loop of a ``molexp run`` invocation: one replica per
+``(experiment, mol_run)`` pair.  Before this module existed, the sweep
+was a plain ``for`` loop in ``molexp.cli.run_cmd._execute_sweep`` that
+serially ``asyncio.run``'d each replica's workflow — so ``molexp run
+--local`` could not parallelise experiments.
+
+:func:`run_sweep` replaces that loop with a one-node pydantic-graph
+(:class:`SweepRoot`) whose body ``asyncio.gather``s replicas under a
+``Semaphore(jobs)``.  The graph shape is deliberately trivial in this
+phase; the point is to have pydantic-graph own sweep lifecycle so
+snapshot, resume, and per-node backend routing (Phase 2/3) can extend it
+without changing the public entry point.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any
+
+from mollog import get_logger
+from pydantic_graph import BaseNode, End, Graph, GraphRunContext
+
+from molexp.config import ProfileConfig
+
+logger = get_logger(__name__)
+
+
+# ── Data classes ────────────────────────────────────────────────────────────
+
+
+@dataclass
+class SweepReplica:
+    """One unit of work in the sweep graph.
+
+    Pairs a molexp ``Run`` with the ``Experiment`` whose workflow should
+    execute it.  The run's ``id`` (fallback: ``id(mol_run)``) keys into
+    :class:`SweepState`.
+
+    Attributes:
+        mol_run: A ``molexp.workspace.Run`` (or any object exposing ``id``).
+        experiment: An object exposing ``workflow.execute(run=, profile_config=)``.
+    """
+
+    mol_run: Any
+    experiment: Any
+
+
+@dataclass
+class SweepState:
+    """Aggregated outcome of a sweep.
+
+    Attributes:
+        outputs: ``replica_id -> WorkflowResult`` for replicas that completed
+            without raising.
+        failures: ``replica_id -> "<ExcType>: <message>"`` for replicas that
+            raised during ``workflow.execute``.  Failures are captured, not
+            re-raised, so one replica's error does not cancel its peers.
+    """
+
+    outputs: dict[str, Any] = field(default_factory=dict)
+    failures: dict[str, str] = field(default_factory=dict)
+
+    @property
+    def all_succeeded(self) -> bool:
+        """``True`` iff no replica raised during ``workflow.execute``."""
+        return not self.failures
+
+    def _sync_from(self, other: "SweepState") -> None:
+        """Mirror *other* into ``self`` in place (pydantic-graph snapshot)."""
+        self.outputs = other.outputs
+        self.failures = other.failures
+
+
+@dataclass
+class SweepDeps:
+    """Dependencies injected into :class:`SweepRoot`."""
+
+    replicas: list[SweepReplica]
+    profile_config: ProfileConfig | None
+    semaphore: asyncio.Semaphore
+
+
+# ── Graph node ──────────────────────────────────────────────────────────────
+
+
+@dataclass
+class SweepRoot(BaseNode[SweepState, SweepDeps, SweepState]):
+    """Single pydantic-graph node that fans out replicas concurrently.
+
+    The body ``asyncio.gather``s one coroutine per replica; each coroutine
+    acquires ``ctx.deps.semaphore`` before calling
+    ``experiment.workflow.execute``.  Exceptions raised by a replica are
+    caught and recorded in :attr:`SweepState.failures`.
+
+    Future phases will split this into one node per replica to enable
+    per-replica backend routing, snapshot/resume at replica granularity,
+    and finer-grained observation.
+    """
+
+    async def run(
+        self, ctx: GraphRunContext[SweepState, SweepDeps]
+    ) -> End[SweepState]:
+        replicas = ctx.deps.replicas
+        sem = ctx.deps.semaphore
+        cfg = ctx.deps.profile_config
+
+        async def _run_one(
+            replica: SweepReplica,
+        ) -> tuple[str, Any, Exception | None]:
+            rid = _replica_id(replica)
+            try:
+                async with sem:
+                    result = await replica.experiment.workflow.execute(
+                        run=replica.mol_run,
+                        profile_config=cfg,
+                    )
+                return rid, result, None
+            except Exception as exc:
+                logger.exception(f"Sweep replica {rid!r} failed")
+                return rid, None, exc
+
+        results = await asyncio.gather(*[_run_one(r) for r in replicas])
+        new_state = SweepState()
+        for rid, output, exc in results:
+            if exc is not None:
+                new_state.failures[rid] = f"{type(exc).__name__}: {exc}"
+            else:
+                new_state.outputs[rid] = output
+
+        ctx.state._sync_from(new_state)
+        return End(ctx.state)
+
+
+# ── Public entry point ──────────────────────────────────────────────────────
+
+
+async def run_sweep(
+    replicas: list[SweepReplica],
+    *,
+    profile_config: ProfileConfig | None = None,
+    jobs: int = 1,
+) -> SweepState:
+    """Execute *replicas* concurrently, bounded by ``jobs``.
+
+    Args:
+        replicas: ``(mol_run, experiment)`` pairs to execute.
+        profile_config: Active :class:`~molexp.config.ProfileConfig` forwarded
+            unchanged to each ``workflow.execute`` call.
+        jobs: Maximum concurrent replicas.  Values ``<= 0`` are clamped up
+            to ``1`` (``Semaphore(0)`` would deadlock).
+
+    Returns:
+        :class:`SweepState` with ``outputs`` and ``failures`` populated.
+        An empty *replicas* list returns an empty state without spinning
+        up a graph.
+    """
+    if not replicas:
+        return SweepState()
+
+    sem = asyncio.Semaphore(max(1, jobs))
+    deps = SweepDeps(
+        replicas=replicas,
+        profile_config=profile_config,
+        semaphore=sem,
+    )
+    state = SweepState()
+    graph: Graph[SweepState, SweepDeps, SweepState] = Graph(nodes=[SweepRoot])
+    run_result = await graph.run(SweepRoot(), state=state, deps=deps)
+    return run_result.output
+
+
+# ── Helpers ─────────────────────────────────────────────────────────────────
+
+
+def _replica_id(replica: SweepReplica) -> str:
+    """Stable string ID for *replica* (``mol_run.id`` with fallback)."""
+    rid = getattr(replica.mol_run, "id", None)
+    if rid is not None:
+        return str(rid)
+    return f"replica-{id(replica.mol_run)}"
diff --git a/src/molexp/workflow/__init__.py b/src/molexp/workflow/__init__.py
index 48cda4b8..5c846bc1 100644
--- a/src/molexp/workflow/__init__.py
+++ b/src/molexp/workflow/__init__.py
@@ -1,52 +1,62 @@
-"""Unified workflow system for molexp.
+"""Molexp workflow layer — public API.
 
-This module provides the core abstractions for building and executing workflows:
-- Task: Base abstraction for executable units
-- Control flow: Built-in tasks for workflow logic
-- Compiler: Workflow compilation and validation
-- Engine: Workflow execution
-"""
+Three ways to define tasks:
+
+1. **Functional** (decorator)::
+
+       wf = workflow(name="pipeline")
+
+       @wf.task
+       async def fetch(ctx: TaskContext) -> FetchResult: ...
+
+       result = await wf.build().execute(run=run)
 
-# Core workflow abstractions
-from .protocol import TaskProtocol
-from .task import Task, TaskConfig
+2. **OOP** (subclass ``Task``)::
 
-# Compiler
-from .compiler import WorkflowCompiler
+       class FetchTask(Task):
+           async def execute(self, ctx: TaskContext) -> FetchResult: ...
 
-# Engine
-from .engine import WorkflowEngine
+       wf = WorkflowBuilder(name="pipeline").add(FetchTask()).build()
+
+3. **Protocol** (any object with ``async execute(ctx)``)::
+
+       # Third-party code — no molexp import required
+       class ExternalProcessor:
+           async def execute(self, ctx) -> dict: ...
+
+       wf = WorkflowBuilder(name="pipeline").add(ExternalProcessor()).build()
+"""
 
-# Models and Registry
-from .link import Link
-from .workflow import Workflow, WorkflowMetadata
-from .registry import (
-    TaskRegistry,
-    get_task_registry,
-    register_task,
-    get_task_class,
-    get_task_id,
-    list_registered_tasks,
-)
+from .cache import Caching
+from .context import ActorContext, TaskContext
+from .protocols import Runnable, Streamable
+from .runtime import WorkflowRuntime
+from .snapshot import TaskSnapshot
+from .spec import WorkflowBuilder, WorkflowSpec, join, parallel_map, workflow
+from .task import Actor, Task
+from .types import WorkflowExecution, WorkflowResult
 
 __all__ = [
-    # Core abstractions
-    "TaskProtocol",
+    # Protocols (for third-party integration)
+    "Runnable",
+    "Streamable",
+    # Convenience base classes
     "Task",
-    "TaskConfig",
-    # Compiler
-    "WorkflowCompiler",
-    # Engine
-    "WorkflowEngine",
-    # Models
-    "Workflow",
-    "WorkflowMetadata",
-    "Link",
-    # Registry
-    "TaskRegistry",
-    "get_task_registry",
-    "register_task",
-    "get_task_class",
-    "get_task_id",
-    "list_registered_tasks",
+    "Actor",
+    # Contexts
+    "TaskContext",
+    "ActorContext",
+    # Workflow building
+    "WorkflowSpec",
+    "WorkflowBuilder",
+    "workflow",
+    "parallel_map",
+    "join",
+    # Execution
+    "WorkflowRuntime",
+    "WorkflowResult",
+    "WorkflowExecution",
+    # Utilities
+    "Caching",
+    "TaskSnapshot",
 ]
diff --git a/src/molexp/workflow/__pycache__/__init__.cpython-312.pyc b/src/molexp/workflow/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index 0ff9ae5f..00000000
Binary files a/src/molexp/workflow/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/__pycache__/config.cpython-312.pyc b/src/molexp/workflow/__pycache__/config.cpython-312.pyc
deleted file mode 100644
index b19d7049..00000000
Binary files a/src/molexp/workflow/__pycache__/config.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/__pycache__/context.cpython-312.pyc b/src/molexp/workflow/__pycache__/context.cpython-312.pyc
deleted file mode 100644
index 6659c4ec..00000000
Binary files a/src/molexp/workflow/__pycache__/context.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/__pycache__/node.cpython-312.pyc b/src/molexp/workflow/__pycache__/node.cpython-312.pyc
deleted file mode 100644
index e18cfc10..00000000
Binary files a/src/molexp/workflow/__pycache__/node.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/__pycache__/registry.cpython-312.pyc b/src/molexp/workflow/__pycache__/registry.cpython-312.pyc
deleted file mode 100644
index bf54ae34..00000000
Binary files a/src/molexp/workflow/__pycache__/registry.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/_pydantic_graph/__init__.py b/src/molexp/workflow/_pydantic_graph/__init__.py
new file mode 100644
index 00000000..b8be2a4e
--- /dev/null
+++ b/src/molexp/workflow/_pydantic_graph/__init__.py
@@ -0,0 +1,11 @@
+"""pydantic-graph backed workflow runtime — internal implementation."""
+
+from .compiler import WorkflowGraphCompiler
+from .persistence import RunStorePersistence
+from .runtime import GraphWorkflowRuntime
+
+__all__ = [
+    "GraphWorkflowRuntime",
+    "WorkflowGraphCompiler",
+    "RunStorePersistence",
+]
diff --git a/src/molexp/workflow/_pydantic_graph/compiler.py b/src/molexp/workflow/_pydantic_graph/compiler.py
new file mode 100644
index 00000000..bb046b02
--- /dev/null
+++ b/src/molexp/workflow/_pydantic_graph/compiler.py
@@ -0,0 +1,158 @@
+"""WorkflowGraphCompiler: converts WorkflowSpec into a pydantic-graph Graph.
+
+Responsibilities:
+1. Validate DAG (no cycles) using graphlib.TopologicalSorter
+2. Group steps into topological **levels** — steps within the same level
+   share no dependencies on each other and can execute in parallel.
+3. Build a pydantic-graph Graph[WorkflowState, WorkflowDeps, WorkflowState]
+   with a single WorkflowStep node class (trampoline pattern)
+4. Assemble WorkflowDeps with the level list injected
+
+The compiled graph can be executed with execute() / iter() / iter_from_persistence().
+"""
+
+from __future__ import annotations
+
+import graphlib
+from collections import defaultdict
+from typing import Any
+
+from pydantic_graph import Graph
+
+from ..spec import TaskRegistration, WorkflowSpec
+from .node import WorkflowStep, _StepEntry
+from .state import WorkflowDeps, WorkflowState
+
+
+class CompiledWorkflow:
+    """Result of compiling a WorkflowSpec.
+
+    Holds the pydantic-graph Graph and a factory for WorkflowDeps
+    so callers can inject run / user_deps at execution time.
+    """
+
+    def __init__(
+        self,
+        graph: Graph[WorkflowState, WorkflowDeps, WorkflowState],
+        levels: list[list[_StepEntry]],
+        sorted_steps: list[_StepEntry],
+    ) -> None:
+        self.graph = graph
+        self._levels = levels
+        self._sorted_steps = sorted_steps
+
+    def make_deps(
+        self,
+        run: Any = None,
+        run_context: Any = None,
+        config: Any = None,
+        user_deps: Any = None,
+        remote_executor: Any = None,
+        run_dir: Any = None,
+    ) -> WorkflowDeps:
+        """Create WorkflowDeps for one execution."""
+
+        class _DepsWithStepList(WorkflowDeps):
+            """WorkflowDeps subclass that carries the level list and flat step list."""
+
+        deps = _DepsWithStepList(
+            run=run,
+            run_context=run_context,
+            config=config,
+            user_deps=user_deps,
+        )
+        deps.step_list = self._sorted_steps  # type: ignore[attr-defined]
+        deps.levels = self._levels  # type: ignore[attr-defined]
+        deps.remote_executor = remote_executor  # type: ignore[attr-defined]
+        deps.run_dir = run_dir  # type: ignore[attr-defined]
+        return deps
+
+
+class WorkflowGraphCompiler:
+    """Compiles a WorkflowSpec into a pydantic-graph Graph.
+
+    Example::
+
+        compiler = WorkflowGraphCompiler()
+        compiled = compiler.compile(spec)
+        state = WorkflowState()
+        deps = compiled.make_deps(run=run, user_deps=my_deps)
+        result = await compiled.graph.run(
+            WorkflowStep(0), state=state, deps=deps
+        )
+    """
+
+    def compile(self, spec: WorkflowSpec) -> CompiledWorkflow:
+        """Validate and compile spec into a runnable graph."""
+        sorted_steps = self._topological_sort(spec)
+        levels = self._compute_levels(sorted_steps)
+        graph: Graph[WorkflowState, WorkflowDeps, WorkflowState] = Graph(
+            nodes=[WorkflowStep]
+        )
+        return CompiledWorkflow(
+            graph=graph, levels=levels, sorted_steps=sorted_steps,
+        )
+
+    def _topological_sort(self, spec: WorkflowSpec) -> list[_StepEntry]:
+        """Return tasks in valid execution order (respecting depends_on)."""
+        step_map: dict[str, TaskRegistration] = {
+            s.name: s for s in spec._tasks
+        }
+
+        # Validate all depends_on references exist
+        for step in spec._tasks:
+            for dep in step.depends_on:
+                if dep not in step_map:
+                    raise ValueError(
+                        f"Step '{step.name}' depends on unknown step '{dep}'"
+                    )
+
+        # Build adjacency: node → set of predecessors
+        dependency_graph: dict[str, set[str]] = {
+            s.name: set(s.depends_on) for s in spec._tasks
+        }
+
+        try:
+            sorter = graphlib.TopologicalSorter(dependency_graph)
+            sorted_names = list(sorter.static_order())
+        except graphlib.CycleError as exc:
+            raise ValueError(f"Workflow '{spec.name}' contains a cycle: {exc}") from exc
+
+        return [
+            _StepEntry(
+                name=name,
+                fn_or_class=step_map[name].fn_or_class,
+                depends_on=step_map[name].depends_on,
+                is_actor=step_map[name].is_actor,
+                remote=step_map[name].remote,
+            )
+            for name in sorted_names
+        ]
+
+    @staticmethod
+    def _compute_levels(sorted_steps: list[_StepEntry]) -> list[list[_StepEntry]]:
+        """Group topologically-sorted steps into parallel levels.
+
+        Steps within the same level have no mutual dependencies and can
+        execute concurrently.  The level of a step is::
+
+            level(s) = 0                                if s has no dependencies
+            level(s) = 1 + max(level(dep) for dep in s.depends_on)  otherwise
+        """
+        if not sorted_steps:
+            return []
+
+        level_of: dict[str, int] = {}
+        for step in sorted_steps:
+            if not step.depends_on:
+                level_of[step.name] = 0
+            else:
+                level_of[step.name] = 1 + max(
+                    level_of[dep] for dep in step.depends_on
+                )
+
+        buckets: dict[int, list[_StepEntry]] = defaultdict(list)
+        for step in sorted_steps:
+            buckets[level_of[step.name]].append(step)
+
+        return [buckets[i] for i in range(max(buckets) + 1)]
diff --git a/src/molexp/workflow/_pydantic_graph/node.py b/src/molexp/workflow/_pydantic_graph/node.py
new file mode 100644
index 00000000..a66f70fe
--- /dev/null
+++ b/src/molexp/workflow/_pydantic_graph/node.py
@@ -0,0 +1,192 @@
+"""WorkflowStep: trampoline BaseNode for level-based parallel step execution.
+
+A single node class handles all steps by tracking `level_index`.  Each level
+contains one or more steps that share no mutual dependencies and can execute
+concurrently via asyncio.gather.  After each level it returns
+``WorkflowStep(level_index + 1)`` until all levels are done, then returns
+``End(state)``.
+
+The graph is:
+    WorkflowStep(0) → WorkflowStep(1) → … → End(state)
+where each node executes all steps in its level in parallel.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from mollog import get_logger
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic_graph import BaseNode, End, GraphRunContext
+
+from .state import WorkflowDeps, WorkflowState
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class WorkflowStep(BaseNode[WorkflowState, WorkflowDeps, WorkflowState]):
+    """Trampoline node that executes one **level** of workflow steps per invocation.
+
+    level_index: index into the level list computed by the compiler.
+    Each level contains steps that can run in parallel.
+    """
+
+    level_index: int = 0
+
+    async def run(
+        self, ctx: GraphRunContext[WorkflowState, WorkflowDeps]
+    ) -> "WorkflowStep | End[WorkflowState]":
+        levels: list[list[_StepEntry]] = ctx.deps.levels  # type: ignore[attr-defined]
+
+        if self.level_index >= len(levels):
+            return End(ctx.state)
+
+        level = levels[self.level_index]
+
+        if len(level) == 1:
+            # Fast path: single step, no gather overhead
+            new_state = await self._execute_single(level[0], ctx)
+        else:
+            # Parallel path: run all steps in this level concurrently
+            new_state = await self._execute_parallel(level, ctx)
+
+        if new_state.failed:
+            ctx.state._sync_from(new_state)
+            return End(ctx.state)
+
+        # Sync the updated state into ctx.state so pydantic-graph snapshots it.
+        ctx.state._sync_from(new_state)
+
+        return WorkflowStep(level_index=self.level_index + 1)
+
+    async def _execute_single(
+        self, entry: _StepEntry, ctx: GraphRunContext[WorkflowState, WorkflowDeps]
+    ) -> WorkflowState:
+        inputs = _gather_inputs(entry, ctx.state)
+
+        from ..context import TaskContext
+
+        step_ctx = TaskContext(
+            state=ctx.state,
+            deps=ctx.deps.user_deps,
+            inputs=inputs,
+            config=ctx.deps.config,
+            run_context=ctx.deps.run_context,
+        )
+
+        logger.debug(f"Executing step {entry.name!r}")
+
+        try:
+            output = await _call_task(entry, step_ctx, deps=ctx.deps)
+            return ctx.state.record(entry.name, output)
+        except Exception as exc:
+            logger.exception(f"Step {entry.name!r} failed")
+            return ctx.state.fail(entry.name, exc)
+
+    async def _execute_parallel(
+        self,
+        entries: list[_StepEntry],
+        ctx: GraphRunContext[WorkflowState, WorkflowDeps],
+    ) -> WorkflowState:
+        from ..context import TaskContext
+
+        async def _run_one(entry: _StepEntry) -> tuple[str, Any, Exception | None]:
+            inputs = _gather_inputs(entry, ctx.state)
+            step_ctx = TaskContext(
+                state=ctx.state,
+                deps=ctx.deps.user_deps,
+                inputs=inputs,
+                config=ctx.deps.config,
+                run_context=ctx.deps.run_context,
+            )
+            try:
+                output = await _call_task(entry, step_ctx, deps=ctx.deps)
+                return (entry.name, output, None)
+            except Exception as exc:
+                logger.exception(f"Step {entry.name!r} failed")
+                return (entry.name, None, exc)
+
+        logger.debug(
+            f"Executing level {self.level_index} in parallel: "
+            f"{[e.name for e in entries]}"
+        )
+
+        results = await asyncio.gather(*[_run_one(e) for e in entries])
+
+        new_state = ctx.state
+        for step_name, output, exc in results:
+            if exc is not None:
+                return new_state.fail(step_name, exc)
+            new_state = new_state.record(step_name, output)
+
+        return new_state
+
+
+def _gather_inputs(entry: _StepEntry, state: WorkflowState) -> Any:
+    """Collect inputs from all upstream dependencies.
+
+    Returns:
+        - ``None`` if the step has no dependencies.
+        - The single upstream output if there is exactly one dependency.
+        - A ``dict[dep_name → output]`` if there are multiple dependencies.
+    """
+    if not entry.depends_on:
+        return None
+
+    if len(entry.depends_on) == 1:
+        return state.step_outputs.get(entry.depends_on[0])
+
+    return {
+        dep: state.step_outputs.get(dep)
+        for dep in entry.depends_on
+    }
+
+
+async def _call_task(
+    entry: "_StepEntry", task_ctx: Any, deps: WorkflowDeps | None = None
+) -> Any:
+    """Dispatch to local execution or remote submission.
+
+    Resolution order:
+    1. Remote execution (if ``entry.remote`` is set and executor available)
+    2. :class:`~Runnable` protocol (has ``.execute()``)
+    3. Bare callable (function decorated with ``@wf.task``)
+    """
+    # 1. Remote gate
+    if entry.remote is not None and deps is not None:
+        remote_executor = getattr(deps, "remote_executor", None)
+        if remote_executor is not None:
+            run_dir = getattr(deps, "run_dir", None)
+            return await remote_executor.execute_remote(
+                entry=entry,
+                inputs=task_ctx.inputs,
+                run_dir=run_dir,
+            )
+
+    # 2. Protocol-based dispatch (Runnable — any object with .execute())
+    from ..protocols import Runnable
+
+    if isinstance(entry.fn_or_class, Runnable):
+        return await entry.fn_or_class.execute(task_ctx)
+
+    # 3. Bare callable (function)
+    if callable(entry.fn_or_class):
+        return await entry.fn_or_class(task_ctx)
+
+    raise TypeError(
+        f"Task '{entry.name}' is neither Runnable nor callable: "
+        f"{type(entry.fn_or_class)}"
+    )
+
+
+@dataclass
+class _StepEntry:
+    """Internal descriptor for a single step held in WorkflowDeps."""
+
+    name: str
+    fn_or_class: Any
+    depends_on: list[str]
+    is_actor: bool = False
+    remote: Any = None
diff --git a/src/molexp/workflow/_pydantic_graph/persistence.py b/src/molexp/workflow/_pydantic_graph/persistence.py
new file mode 100644
index 00000000..37b0ded8
--- /dev/null
+++ b/src/molexp/workflow/_pydantic_graph/persistence.py
@@ -0,0 +1,185 @@
+"""RunStorePersistence: pydantic-graph BaseStatePersistence backed by a single workflow.json.
+
+All workflow execution state (steps + end) is consolidated into one file:
+    <run_dir>/execution/<execution_id>/workflow.json
+
+This replaces the previous per-snapshot file layout
+(``WorkflowStep:{uuid}.json``, ``__end__.json``), making it easy to inspect
+progress with a single ``cat workflow.json``.
+"""
+
+from __future__ import annotations
+
+import json
+from mollog import get_logger
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+from time import perf_counter
+from typing import Any, AsyncIterator
+
+from pydantic_graph import End, exceptions
+from pydantic_graph.nodes import BaseNode
+from pydantic_graph.persistence import BaseStatePersistence, EndSnapshot, NodeSnapshot
+
+from .state import WorkflowState
+
+logger = get_logger(__name__)
+
+
+class RunStorePersistence(BaseStatePersistence[WorkflowState, WorkflowState]):
+    """Persist workflow graph snapshots inside a molexp Run directory.
+
+    All snapshots are written atomically to a single ``workflow.json``:
+
+    .. code-block:: json
+
+        {
+          "execution_id": "exec-abc12345",
+          "status": "running",
+          "steps": [
+            {"index": 1, "status": "success", "step_outputs": {...}},
+            {"index": 2, "status": "running", "step_outputs": {...}}
+          ],
+          "end": null
+        }
+
+    Args:
+        run_dir: Path to the run's directory (``run.run_dir`` or equivalent).
+        execution_id: Unique string for this execution (stored as sub-directory).
+    """
+
+    def __init__(self, run_dir: Path, execution_id: str) -> None:
+        self._exec_dir = run_dir / "execution" / execution_id
+        self._exec_dir.mkdir(parents=True, exist_ok=True)
+        self._last_snapshot: NodeSnapshot | EndSnapshot | None = None
+        self._workflow_file = self._exec_dir / "workflow.json"
+        # In-memory state; written atomically on every mutation.
+        self._state: dict[str, Any] = {
+            "execution_id": execution_id,
+            "status": "running",
+            "steps": [],
+            "end": None,
+        }
+        self._write_workflow()
+
+    # ── BaseStatePersistence protocol ────────────────────────────────────────
+
+    async def snapshot_node(
+        self, state: WorkflowState, next_node: BaseNode
+    ) -> None:
+        self._last_snapshot = NodeSnapshot(state=state, node=next_node)
+        if type(next_node).__name__ == "WorkflowStep":
+            level_index = getattr(next_node, "level_index", len(self._state["steps"]))
+            self._state["steps"].append({
+                "_snapshot_id": self._last_snapshot.id,
+                "index": level_index + 1,  # 1-indexed for human display
+                "status": "pending",
+                "step_outputs": {
+                    k: _safe_serialize(v)
+                    for k, v in state.step_outputs.items()
+                },
+            })
+            self._write_workflow()
+
+    async def snapshot_node_if_new(
+        self,
+        snapshot_id: str,
+        state: WorkflowState,
+        next_node: BaseNode,
+    ) -> None:
+        if self._last_snapshot and self._last_snapshot.id == snapshot_id:
+            return
+        await self.snapshot_node(state, next_node)
+
+    async def snapshot_end(self, state: WorkflowState, end: End[WorkflowState]) -> None:
+        self._last_snapshot = EndSnapshot(state=state, result=end)
+        self._state["status"] = "completed"
+        self._state["end"] = {
+            "step_outputs": {
+                k: _safe_serialize(v)
+                for k, v in state.step_outputs.items()
+            },
+        }
+        self._write_workflow()
+
+    @asynccontextmanager
+    async def record_run(self, snapshot_id: str) -> AsyncIterator[None]:
+        if self._last_snapshot is None or snapshot_id != self._last_snapshot.id:
+            raise LookupError(f"No snapshot found with id={snapshot_id!r}")
+
+        assert isinstance(self._last_snapshot, NodeSnapshot), (
+            "Only NodeSnapshot can be recorded"
+        )
+        exceptions.GraphNodeStatusError.check(self._last_snapshot.status)
+        self._last_snapshot.status = "running"
+        self._update_snapshot_status(snapshot_id, "running")
+
+        start = perf_counter()
+        try:
+            yield
+        except Exception:
+            self._last_snapshot.duration = perf_counter() - start
+            self._last_snapshot.status = "error"
+            self._update_snapshot_status(snapshot_id, "error")
+            raise
+        else:
+            self._last_snapshot.duration = perf_counter() - start
+            self._last_snapshot.status = "success"
+            self._update_snapshot_status(snapshot_id, "success")
+
+    async def load_all(self) -> list:
+        """Return all stored snapshots (in-memory only)."""
+        if self._last_snapshot is not None:
+            return [self._last_snapshot]
+        return []
+
+    async def load_next(self) -> NodeSnapshot[WorkflowState, WorkflowState] | None:
+        if (
+            isinstance(self._last_snapshot, NodeSnapshot)
+            and self._last_snapshot.status == "created"
+        ):
+            self._last_snapshot.status = "pending"
+            return self._last_snapshot
+        return None
+
+    # ── Internal helpers ─────────────────────────────────────────────────────
+
+    def _update_snapshot_status(self, snapshot_id: str, status: str) -> None:
+        for step in self._state["steps"]:
+            if step.get("_snapshot_id") == snapshot_id:
+                step["status"] = status
+                self._write_workflow()
+                return
+
+    def _write_workflow(self) -> None:
+        """Atomically write workflow.json (tmp → rename)."""
+        clean = {
+            "execution_id": self._state["execution_id"],
+            "status": self._state["status"],
+            "steps": [
+                {k: v for k, v in step.items() if k != "_snapshot_id"}
+                for step in self._state["steps"]
+            ],
+            "end": self._state["end"],
+        }
+        tmp = self._workflow_file.with_suffix(".tmp")
+        tmp.write_text(json.dumps(clean, indent=2, default=str))
+        os.replace(tmp, self._workflow_file)
+
+
+def _safe_serialize(obj: Any) -> Any:
+    """Best-effort serialization for snapshot data."""
+    try:
+        json.dumps(obj)
+        return obj
+    except (TypeError, ValueError):
+        if hasattr(obj, "model_dump"):
+            return obj.model_dump()
+        if hasattr(obj, "__dict__"):
+            return {
+                k: _safe_serialize(v)
+                for k, v in obj.__dict__.items()
+                if not k.startswith("_")
+            }
+        return str(obj)
diff --git a/src/molexp/workflow/_pydantic_graph/runtime.py b/src/molexp/workflow/_pydantic_graph/runtime.py
new file mode 100644
index 00000000..2a729ef2
--- /dev/null
+++ b/src/molexp/workflow/_pydantic_graph/runtime.py
@@ -0,0 +1,510 @@
+"""GraphWorkflowRuntime: concrete WorkflowRuntime backed by pydantic-graph.
+
+Implements the WorkflowRuntime interface for all three modes:
+- execute(): run to completion, return WorkflowResult
+- start(): launch in background, return WorkflowExecution handle
+- resume(): continue from persisted snapshot
+- stream()/iter(): async step-by-step iteration
+"""
+
+from __future__ import annotations
+
+import asyncio
+import uuid
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, AsyncGenerator
+
+from mollog import get_logger
+
+from molexp.config import ProfileConfig
+
+from ..runtime import WorkflowRuntime
+from ..types import WorkflowExecution, WorkflowResult
+from .compiler import CompiledWorkflow, WorkflowGraphCompiler
+from .node import WorkflowStep
+from .persistence import RunStorePersistence
+from .state import WorkflowDeps, WorkflowState
+
+logger = get_logger(__name__)
+
+_compiler = WorkflowGraphCompiler()
+
+
+def _get_run_dir(run: Any) -> Path | None:
+    """Extract run directory from a molexp Run object if available."""
+    if run is None:
+        return None
+    for attr in ("run_dir", "path", "root"):
+        val = getattr(run, attr, None)
+        if val is not None:
+            return Path(val)
+    return None
+
+
+def _get_run_id(run: Any) -> str | None:
+    """Extract a stable run identifier from a molexp Run-like object."""
+    if run is None:
+        return None
+    return getattr(run, "id", getattr(run, "run_id", None))
+
+
+def _make_execution_id(run_id: str | None, run_dir: Path | None) -> str:
+    """Build an execution ID derived from run_id.
+
+    First execution: ``exec-{run_id}``
+    Retries:         ``exec-{run_id}-2``, ``exec-{run_id}-3``, …
+
+    Falls back to a random ID when *run_id* is not available.
+    """
+    if run_id is None:
+        return f"exec-{uuid.uuid4().hex[:8]}"
+
+    base = f"exec-{run_id}"
+    if run_dir is None:
+        return base
+
+    exec_root = run_dir / "execution"
+    if not exec_root.exists():
+        return base
+
+    existing = [p for p in exec_root.iterdir() if p.name.startswith(base)]
+    if not existing:
+        return base
+    return f"{base}-{len(existing) + 1}"
+
+
+class GraphWorkflowRuntime(WorkflowRuntime):
+    """Workflow runtime powered by pydantic-graph.
+
+    Caches compiled graphs by workflow_id so repeated executions of the
+    same spec skip recompilation.
+    """
+
+    def __init__(self) -> None:
+        self._compiled: dict[str, CompiledWorkflow] = {}
+
+    def _get_compiled(self, spec: Any) -> CompiledWorkflow:
+        wf_id = spec.workflow_id
+        if wf_id not in self._compiled:
+            self._compiled[wf_id] = _compiler.compile(spec)
+        return self._compiled[wf_id]
+
+    @staticmethod
+    def _build_deps(
+        compiled: CompiledWorkflow,
+        *,
+        run: Any,
+        run_context: Any,
+        profile_config: ProfileConfig | None,
+        kwargs: dict[str, Any],
+    ) -> tuple[WorkflowDeps, Path | None]:
+        """Build WorkflowDeps with optional remote executor from kwargs.
+
+        When *run_context* is provided, its attached :attr:`config`
+        takes precedence over *profile_config* — the context was
+        constructed with a fixed ``ProfileConfig`` and must be honoured.
+        """
+        user_deps = kwargs.get("deps")
+        submitors = kwargs.get("submitors")
+        run_dir = (
+            Path(run_context.work_dir)
+            if run_context is not None
+            else _get_run_dir(run)
+        )
+
+        effective_config = (
+            run_context.config if run_context is not None else profile_config
+        )
+
+        remote_executor = None
+        if submitors:
+            from ..remote import RemoteStepExecutor
+            remote_executor = RemoteStepExecutor(submitors)
+
+        deps = compiled.make_deps(
+            run=run,
+            run_context=run_context,
+            config=effective_config,
+            user_deps=user_deps,
+            remote_executor=remote_executor,
+            run_dir=run_dir,
+        )
+        return deps, run_dir
+
+    @staticmethod
+    def _set_run_status(run_context: Any, *, failed: bool, persist: bool) -> None:
+        if run_context is None or not hasattr(run_context, "context"):
+            return
+
+        from molexp.workspace.run import RunStatus
+
+        status = RunStatus.FAILED if failed else RunStatus.SUCCEEDED
+
+        run_context.context.status["run"] = status
+        if persist and hasattr(run_context, "_save_context"):
+            run_context._save_context()
+
+    @asynccontextmanager
+    async def _execution_scope(
+        self,
+        *,
+        run: Any,
+        run_context: Any,
+        profile_config: ProfileConfig | None,
+    ) -> AsyncGenerator[Any, None]:
+        if run is not None and run_context is not None:
+            raise ValueError("Pass either run or run_context, not both")
+
+        if run_context is not None:
+            if profile_config is not None:
+                raise ValueError(
+                    "Cannot combine run_context with profile_config.  "
+                    "The profile must be fixed on the RunContext at construction "
+                    "time — late-binding is not permitted."
+                )
+            yield run_context
+            return
+
+        if run is not None:
+            from molexp.workspace.run import RunContext as WorkspaceRunContext
+            managed_ctx = WorkspaceRunContext(run, profile_config=profile_config)
+            with managed_ctx:
+                yield managed_ctx
+            return
+
+        yield None
+
+    # ── execute ──────────────────────────────────────────────────────────────
+
+    async def execute(
+        self,
+        spec: Any,
+        run: Any = None,
+        run_context: Any = None,
+        *,
+        profile_config: ProfileConfig | None = None,
+        **kwargs: Any,
+    ) -> WorkflowResult:
+        """Run the workflow to completion and return a WorkflowResult."""
+        if run is not None and run_context is not None:
+            raise ValueError("Pass either run or run_context, not both")
+        if run_context is not None and profile_config is not None:
+            raise ValueError(
+                "Cannot combine run_context with profile_config.  "
+                "The profile must be fixed on the RunContext at construction time."
+            )
+
+        compiled = self._get_compiled(spec)
+        # Derive execution_id from run_id so all layers share the same base ID.
+        _early_run = run_context.run if run_context is not None else run
+        _early_run_id = _get_run_id(_early_run)
+        _early_run_dir = (
+            Path(run_context.work_dir) if run_context is not None
+            else _get_run_dir(_early_run)
+        )
+        execution_id = _make_execution_id(_early_run_id, _early_run_dir)
+        owner_supplied_context = run_context
+
+        try:
+            async with self._execution_scope(
+                run=run,
+                run_context=run_context,
+                profile_config=profile_config,
+            ) as active_run_context:
+                effective_run = (
+                    active_run_context.run
+                    if active_run_context is not None
+                    else run
+                )
+                deps, run_dir = self._build_deps(
+                    compiled,
+                    run=effective_run,
+                    run_context=active_run_context,
+                    profile_config=profile_config,
+                    kwargs=kwargs,
+                )
+                state = WorkflowState()
+                run_id = _get_run_id(deps.run)
+
+                persistence = (
+                    RunStorePersistence(run_dir=run_dir, execution_id=execution_id)
+                    if run_dir is not None
+                    else None
+                )
+
+                if persistence is not None:
+                    run_result = await compiled.graph.run(
+                        WorkflowStep(0),
+                        state=state,
+                        deps=deps,
+                        persistence=persistence,
+                    )
+                else:
+                    run_result = await compiled.graph.run(
+                        WorkflowStep(0),
+                        state=state,
+                        deps=deps,
+                    )
+                result_state = run_result.output
+
+                if result_state.failed:
+                    self._set_run_status(
+                        active_run_context,
+                        failed=True,
+                        persist=owner_supplied_context is not None,
+                    )
+                    return WorkflowResult(
+                        status="failed",
+                        outputs=result_state.step_outputs,
+                        run_id=run_id,
+                        execution_id=execution_id,
+                    )
+
+                self._set_run_status(
+                    active_run_context,
+                    failed=False,
+                    persist=owner_supplied_context is not None,
+                )
+                return WorkflowResult(
+                    status="completed",
+                    outputs=result_state.step_outputs,
+                    run_id=run_id,
+                    execution_id=execution_id,
+                )
+        except Exception:
+            self._set_run_status(
+                owner_supplied_context,
+                failed=True,
+                persist=owner_supplied_context is not None,
+            )
+            logger.exception(f"Workflow {spec.name!r} execution failed")
+            return WorkflowResult(
+                status="failed",
+                outputs={},
+                run_id=_get_run_id(
+                    owner_supplied_context.run
+                    if owner_supplied_context is not None
+                    else run
+                ),
+                execution_id=execution_id,
+            )
+
+    # ── start ────────────────────────────────────────────────────────────────
+
+    async def start(
+        self,
+        spec: Any,
+        run: Any = None,
+        run_context: Any = None,
+        *,
+        profile_config: ProfileConfig | None = None,
+        **kwargs: Any,
+    ) -> WorkflowExecution:
+        """Launch workflow as background asyncio task."""
+        if run is not None and run_context is not None:
+            raise ValueError("Pass either run or run_context, not both")
+        if run_context is not None and profile_config is not None:
+            raise ValueError(
+                "Cannot combine run_context with profile_config.  "
+                "The profile must be fixed on the RunContext at construction time."
+            )
+
+        compiled = self._get_compiled(spec)
+        owner_supplied_context = run_context
+        effective_run = (
+            run_context.run
+            if run_context is not None
+            else run
+        )
+        run_id = _get_run_id(effective_run)
+        _early_run_dir = (
+            Path(run_context.work_dir) if run_context is not None
+            else _get_run_dir(effective_run)
+        )
+        execution_id = _make_execution_id(run_id, _early_run_dir)
+
+        handle = _GraphWorkflowExecution(
+            execution_id=execution_id,
+            workflow_id=spec.workflow_id,
+            run_id=run_id,
+        )
+
+        async def _bg() -> None:
+            try:
+                async with self._execution_scope(
+                    run=run,
+                    run_context=run_context,
+                    profile_config=profile_config,
+                ) as active_run_context:
+                    effective_run = (
+                        active_run_context.run
+                        if active_run_context is not None
+                        else run
+                    )
+                    deps, _ = self._build_deps(
+                        compiled,
+                        run=effective_run,
+                        run_context=active_run_context,
+                        profile_config=profile_config,
+                        kwargs=kwargs,
+                    )
+                    state = WorkflowState()
+                    run_result = await compiled.graph.run(
+                        WorkflowStep(0), state=state, deps=deps
+                    )
+                    result_state = run_result.output
+                    self._set_run_status(
+                        active_run_context,
+                        failed=result_state.failed,
+                        persist=owner_supplied_context is not None,
+                    )
+                    handle._result = WorkflowResult(
+                        status="failed" if result_state.failed else "completed",
+                        outputs=result_state.step_outputs,
+                        run_id=_get_run_id(effective_run),
+                        execution_id=execution_id,
+                    )
+            except Exception:
+                self._set_run_status(
+                    owner_supplied_context,
+                    failed=True,
+                    persist=owner_supplied_context is not None,
+                )
+                handle._result = WorkflowResult(
+                    status="failed",
+                    outputs={},
+                    run_id=handle.run_id,
+                    execution_id=execution_id,
+                )
+                logger.exception(f"Background workflow {spec.name!r} failed")
+            finally:
+                handle._done_event.set()
+
+        handle._task = asyncio.create_task(_bg())
+        return handle
+
+    # ── resume ───────────────────────────────────────────────────────────────
+
+    async def resume(
+        self, spec: Any, run: Any, execution_id: str, **kwargs: Any
+    ) -> WorkflowExecution:
+        """Resume a workflow from persisted state."""
+        run_dir = _get_run_dir(run)
+        if run_dir is None:
+            raise ValueError("Cannot resume workflow without a run directory")
+
+        compiled = self._get_compiled(spec)
+        # On resume we rebuild the ProfileConfig from the persisted
+        # run.metadata so user tasks see the same ctx.config data.
+        profile_cfg: ProfileConfig | None = None
+        meta = getattr(run, "metadata", None)
+        if meta is not None:
+            profile_cfg = ProfileConfig(
+                getattr(meta, "config", {}) or {},
+                name=getattr(meta, "profile", None),
+            )
+        deps, _ = self._build_deps(
+            compiled,
+            run=run,
+            run_context=None,
+            profile_config=profile_cfg,
+            kwargs=kwargs,
+        )
+        persistence = RunStorePersistence(run_dir=run_dir, execution_id=execution_id)
+
+        handle = _GraphWorkflowExecution(
+            execution_id=execution_id,
+            workflow_id=spec.workflow_id,
+            run_id=_get_run_id(run),
+        )
+
+        async def _bg() -> None:
+            try:
+                async with compiled.graph.iter_from_persistence(
+                    persistence=persistence,
+                    deps=deps,
+                ) as run_ctx:
+                    async for _node in run_ctx:
+                        pass
+                    result_state = run_ctx.result.output if run_ctx.result else WorkflowState(failed=True, error="No result")
+
+                handle._result = WorkflowResult(
+                    status="failed" if result_state.failed else "completed",
+                    outputs=result_state.step_outputs,
+                    run_id=handle.run_id,
+                    execution_id=execution_id,
+                )
+            except Exception:
+                handle._result = WorkflowResult(
+                    status="failed",
+                    outputs={},
+                    run_id=handle.run_id,
+                    execution_id=execution_id,
+                )
+                logger.exception(f"Resume of workflow {spec.name!r} failed")
+            finally:
+                handle._done_event.set()
+
+        handle._task = asyncio.create_task(_bg())
+        return handle
+
+    # ── iter ─────────────────────────────────────────────────────────────────
+
+    def iter(self, spec: Any, run: Any = None, **kwargs: Any) -> Any:
+        """Return an async context manager for step-by-step iteration."""
+        effective_run_context = kwargs.get("run_context")
+        if run is not None and effective_run_context is not None:
+            raise ValueError("Pass either run or run_context, not both")
+
+        compiled = self._get_compiled(spec)
+        effective_run = (
+            effective_run_context.run
+            if effective_run_context is not None
+            else run
+        )
+        deps, _ = self._build_deps(
+            compiled,
+            run=effective_run,
+            run_context=effective_run_context,
+            profile_config=kwargs.get("profile_config"),
+            kwargs=kwargs,
+        )
+        state = WorkflowState()
+        return compiled.graph.iter(WorkflowStep(0), state=state, deps=deps)
+
+    # ── stream ───────────────────────────────────────────────────────────────
+
+    def stream(self, spec: Any, run: Any = None, **kwargs: Any) -> Any:
+        """Alias for iter() — streaming Actor support in a future phase."""
+        return self.iter(spec, run=run, **kwargs)
+
+
+class _GraphWorkflowExecution(WorkflowExecution):
+    """Concrete WorkflowExecution returned by start() / resume()."""
+
+    def __init__(self, execution_id: str, workflow_id: str, run_id: str | None) -> None:
+        super().__init__(
+            execution_id=execution_id,
+            workflow_id=workflow_id,
+            run_id=run_id,
+        )
+        self._result: WorkflowResult | None = None
+        self._done_event: asyncio.Event = asyncio.Event()
+        self._task: asyncio.Task | None = None
+
+    async def wait(self) -> WorkflowResult:
+        """Block until the workflow finishes and return the result."""
+        await self._done_event.wait()
+        assert self._result is not None
+        return self._result
+
+    async def cancel(self) -> None:
+        """Cancel the background task."""
+        if self._task is not None and not self._task.done():
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+        self._done_event.set()
diff --git a/src/molexp/workflow/_pydantic_graph/state.py b/src/molexp/workflow/_pydantic_graph/state.py
new file mode 100644
index 00000000..4a5239af
--- /dev/null
+++ b/src/molexp/workflow/_pydantic_graph/state.py
@@ -0,0 +1,67 @@
+"""Internal pydantic-graph state and deps types.
+
+Users never import these directly — they use the public StepContext/WorkflowResult API.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class WorkflowState:
+    """Shared mutable state threaded through all workflow steps via pydantic-graph.
+
+    step_outputs maps step_name → output value as steps complete.
+    The final entry in step_outputs is the workflow result when done.
+    """
+
+    step_outputs: dict[str, Any] = field(default_factory=dict)
+    failed: bool = False
+    error: str | None = None
+
+    def record(self, step_name: str, output: Any) -> "WorkflowState":
+        """Return a new state with the given step output recorded."""
+        return WorkflowState(
+            step_outputs={**self.step_outputs, step_name: output},
+            failed=self.failed,
+            error=self.error,
+        )
+
+    def fail(self, step_name: str, exc: Exception) -> "WorkflowState":
+        """Return a new state marked as failed."""
+        return WorkflowState(
+            step_outputs=self.step_outputs,
+            failed=True,
+            error=f"Step '{step_name}' failed: {exc}",
+        )
+
+
+    def _sync_from(self, other: "WorkflowState") -> None:
+        """Update this state in-place from *other*.
+
+        pydantic-graph holds a reference to the state object and snapshots it
+        after each node.  We MUST mutate the original reference so the
+        snapshot reflects the latest outputs.  This method centralises that
+        necessary mutation in one place.
+        """
+        self.step_outputs = other.step_outputs
+        self.failed = other.failed
+        self.error = other.error
+
+
+@dataclass
+class WorkflowDeps:
+    """Dependencies injected into every pydantic-graph node.
+
+    run: The molexp Run associated with this execution (may be None).
+    run_context: The active RunContext associated with this execution (may be None).
+    config: The active :class:`~molexp.config.ProfileConfig` (may be None).
+    user_deps: Application-level deps forwarded from the caller.
+    """
+
+    run: Any = None
+    run_context: Any = None
+    config: Any = None  # molexp.config.ProfileConfig | None
+    user_deps: Any = None
diff --git a/src/molexp/workflow/cache.py b/src/molexp/workflow/cache.py
new file mode 100644
index 00000000..8aca3765
--- /dev/null
+++ b/src/molexp/workflow/cache.py
@@ -0,0 +1,220 @@
+"""Execution result caching with LRU eviction and format versioning.
+
+Each cache entry is keyed by the combination of a TaskSnapshot key and an input hash:
+    cache_key = f(snapshot.key, input_hash)
+
+Features:
+    - LRU eviction when entry count exceeds max_entries
+    - Format version field for forward-compatible schema evolution
+    - Atomic file writes to prevent corruption
+    - Robust input hashing with type-aware serialization
+
+Usage:
+    cache = Caching(store_dir=Path("~/.molexp/cache"), max_entries=1000)
+    cache.initialize()
+
+    hit = cache.get(snapshot, inputs)
+    if hit is None:
+        result = run_task(...)
+        cache.put(snapshot, inputs, result)
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from mollog import get_logger
+import os
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+from .snapshot import TaskSnapshot
+
+logger = get_logger(__name__)
+
+# Bump this when CacheEntry schema changes in a backwards-incompatible way.
+CACHE_FORMAT_VERSION = 1
+
+
+def _robust_json_default(obj: Any) -> Any:
+    """Type-aware JSON serializer for cache input hashing.
+
+    Large array-like objects (>10 000 elements) are hashed rather than
+    fully serialized to avoid excessive memory usage.
+    """
+    if hasattr(obj, "tolist"):
+        size = obj.size if hasattr(obj, "size") else len(obj)
+        if size > 10_000:
+            # Hash large arrays instead of serializing to avoid OOM
+            raw_bytes = obj.tobytes() if hasattr(obj, "tobytes") else str(obj).encode()
+            digest = hashlib.sha256(raw_bytes).hexdigest()
+            return {
+                "__type__": "ndarray_digest",
+                "shape": list(obj.shape) if hasattr(obj, "shape") else [size],
+                "dtype": str(obj.dtype),
+                "digest": digest,
+            }
+        return {"__type__": "ndarray", "data": obj.tolist(), "dtype": str(obj.dtype)}
+    if isinstance(obj, Path):
+        return {"__type__": "Path", "path": str(obj)}
+    if isinstance(obj, datetime):
+        return {"__type__": "datetime", "iso": obj.isoformat()}
+    if hasattr(obj, "model_dump"):
+        return {"__type__": "pydantic", "data": obj.model_dump()}
+    return str(obj)
+
+
+class CacheEntry(BaseModel):
+    """A single cache record = snapshot + inputs + result."""
+
+    version: int = CACHE_FORMAT_VERSION
+    snapshot_key: str
+    input_hash: str
+    cache_key: str
+    task_id: str
+    task_type: str
+    result: dict[str, Any]
+    created_at: datetime
+
+
+class Caching:
+    """File-backed execution cache with LRU eviction.
+
+    Each entry is keyed by the combination of a TaskSnapshot key and the hash of
+    the concrete inputs.
+
+    Args:
+        store_dir: Directory for cache files.
+        max_entries: Maximum number of cache entries (0 = unlimited).
+    """
+
+    def __init__(self, store_dir: Path, max_entries: int = 10000) -> None:
+        self._store_dir = Path(store_dir)
+        self._max_entries = max_entries
+
+    def initialize(self) -> None:
+        """Ensure the store directory exists."""
+        self._store_dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """Cache statistics: entry_count, total_size_bytes, max_entries."""
+        if not self._store_dir.exists():
+            return {"entry_count": 0, "total_size_bytes": 0, "max_entries": self._max_entries}
+        entries = list(self._store_dir.glob("*.json"))
+        total_size = sum(p.stat().st_size for p in entries)
+        return {
+            "entry_count": len(entries),
+            "total_size_bytes": total_size,
+            "max_entries": self._max_entries,
+        }
+
+    def get(self, snapshot: TaskSnapshot, inputs: dict[str, Any]) -> dict[str, Any] | None:
+        """Look up a cached result. Returns None on miss, version mismatch, or corruption."""
+        cache_key = self._compute_cache_key(snapshot.key, self._compute_input_hash(inputs))
+        path = self._key_path(cache_key)
+        if not path.exists():
+            return None
+
+        try:
+            entry = CacheEntry.model_validate_json(path.read_text())
+        except Exception:
+            logger.warning(f"Corrupted cache entry {path.name}, removing")
+            path.unlink(missing_ok=True)
+            return None
+
+        if entry.version != CACHE_FORMAT_VERSION:
+            logger.debug(
+                f"Cache version mismatch for {cache_key}: "
+                f"entry={entry.version}, current={CACHE_FORMAT_VERSION}"
+            )
+            path.unlink(missing_ok=True)
+            return None
+
+        path.touch()
+        return entry.result
+
+    def put(
+        self,
+        snapshot: TaskSnapshot,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+    ) -> None:
+        """Store a result in the cache. Triggers LRU eviction if limit exceeded."""
+        input_hash = self._compute_input_hash(inputs)
+        cache_key = self._compute_cache_key(snapshot.key, input_hash)
+        entry = CacheEntry(
+            version=CACHE_FORMAT_VERSION,
+            snapshot_key=snapshot.key,
+            input_hash=input_hash,
+            cache_key=cache_key,
+            task_id=snapshot.task_id,
+            task_type=snapshot.task_type,
+            result=result,
+            created_at=datetime.now(timezone.utc),
+        )
+        self._store_dir.mkdir(parents=True, exist_ok=True)
+        self._atomic_write(self._key_path(cache_key), entry.model_dump_json(indent=2))
+        if self._max_entries > 0:
+            self._evict_if_needed()
+
+    def invalidate(self, snapshot: TaskSnapshot, inputs: dict[str, Any]) -> bool:
+        """Remove a single cache entry. Returns True if the entry existed."""
+        cache_key = self._compute_cache_key(snapshot.key, self._compute_input_hash(inputs))
+        path = self._key_path(cache_key)
+        if path.exists():
+            path.unlink()
+            return True
+        return False
+
+    def clear(self) -> int:
+        """Remove all cache entries. Returns count removed."""
+        count = 0
+        if self._store_dir.exists():
+            for p in self._store_dir.glob("*.json"):
+                p.unlink()
+                count += 1
+        return count
+
+    def _key_path(self, cache_key: str) -> Path:
+        return self._store_dir / f"{cache_key}.json"
+
+    def _evict_if_needed(self) -> None:
+        entries = list(self._store_dir.glob("*.json"))
+        if len(entries) <= self._max_entries:
+            return
+        entries.sort(key=lambda p: p.stat().st_mtime)
+        to_remove = len(entries) - self._max_entries
+        for path in entries[:to_remove]:
+            path.unlink(missing_ok=True)
+            logger.debug(f"Evicted cache entry: {path.name}")
+
+    @staticmethod
+    def _atomic_write(path: Path, content: str) -> None:
+        fd, tmp_path = tempfile.mkstemp(
+            dir=path.parent, suffix=".tmp", prefix=f".{path.stem}_"
+        )
+        try:
+            with os.fdopen(fd, "w") as f:
+                f.write(content)
+            os.replace(tmp_path, path)
+        except BaseException:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+            raise
+
+    @staticmethod
+    def _compute_cache_key(snapshot_key: str, input_hash: str) -> str:
+        combined = f"{snapshot_key}|{input_hash}"
+        return hashlib.sha256(combined.encode()).hexdigest()
+
+    @staticmethod
+    def _compute_input_hash(inputs: dict[str, Any]) -> str:
+        raw = json.dumps(inputs, sort_keys=True, default=_robust_json_default)
+        return hashlib.sha256(raw.encode()).hexdigest()
diff --git a/src/molexp/workflow/compiler/__init__.py b/src/molexp/workflow/compiler/__init__.py
deleted file mode 100644
index 563daa81..00000000
--- a/src/molexp/workflow/compiler/__init__.py
+++ /dev/null
@@ -1,11 +0,0 @@
-"""Workflow compiler module.
-
-Provides workflow compilation and validation.
-"""
-
-from .core import CompiledWorkflow, WorkflowCompiler
-
-__all__ = [
-    "WorkflowCompiler",
-    "CompiledWorkflow",
-]
diff --git a/src/molexp/workflow/compiler/core.py b/src/molexp/workflow/compiler/core.py
deleted file mode 100644
index c4be3e25..00000000
--- a/src/molexp/workflow/compiler/core.py
+++ /dev/null
@@ -1,465 +0,0 @@
-"""Core compiler classes for workflow compilation and type-driven dispatch.
-
-This module implements workflow compilation with automatic task type detection and
-channel allocation for actor-based message passing:
-
-1. **WorkflowCompiler**: Main entry point for workflow compilation. Validates workflow
-   structure, detects task execution types via return type inspection, and allocates
-   message channels for actor communication.
-
-2. **CompiledWorkflow**: Encapsulates compiled workflow with high-level access methods
-   for topology, execution plans, task types, and channel configurations.
-
-Type Detection:
-    The compiler inspects execute() method return annotations to classify tasks:
-    - `-> dict`: BATCH task (executes once)
-    - `-> AsyncGenerator[None, dict]`: ACTOR task (runs continuously)
-
-Channel Allocation:
-    For links involving actors, the compiler allocates asyncio.Queue configurations
-    with configurable buffer sizes. Channel routing uses Link.mapping for logical
-    channel name resolution.
-
-Example:
-    Basic compilation::
-
-        compiler = WorkflowCompiler()
-        compiled = compiler.compile(workflow)
-        task_types = compiled.get_task_types()
-        channels = compiled.get_channels()
-
-    Accessing execution plan::
-
-        plan = compiled.get_execution_plan()
-        topology = compiled.get_topology()
-"""
-
-import inspect
-from collections.abc import AsyncGenerator
-from typing import Any, List, get_origin
-
-from ..execution_type import TaskExecutionType
-from ..workflow import Workflow
-
-
-class CompiledWorkflow:
-    """Encapsulates a compiled workflow with high-level access methods.
-    
-    This class provides a user-friendly interface to compiled workflows.
-    Users interact with high-level methods like get_topology() and 
-    get_execution_plan().
-    
-    Example:
-        >>> compiler = WorkflowCompiler()
-        >>> compiled = compiler.compile(workflow)
-        >>> topology = compiled.get_topology()
-        >>> plan = compiled.get_execution_plan()
-    """
-
-    def __init__(self, workflow: Workflow, task_types: dict[str, TaskExecutionType] | None = None, channels: dict[str, Any] | None = None):
-        """Initialize with validated Workflow.
-
-        Args:
-            workflow: Validated workflow
-            task_types: Optional dict of task_id -> TaskExecutionType
-            channels: Optional dict of channel configurations
-        """
-        self._workflow = workflow
-        self._task_types = task_types or {}
-        self._channels = channels or {}
-
-    def get_workflow(self) -> Workflow:
-        """Get underlying Workflow for debugging or advanced use.
-        
-        Returns:
-            The underlying Workflow object
-        """
-        return self._workflow
-
-    def get_topology(self) -> dict[str, Any]:
-        """Get execution topology as a dictionary.
-        
-        Returns a dictionary containing nodes, edges, and metadata describing
-        the workflow structure in a user-friendly format.
-        
-        Returns:
-            Dictionary with 'nodes', 'edges', and 'metadata' keys
-            
-        Example:
-            >>> topology = compiled.get_topology()
-            >>> print(topology['nodes'])  # List of task nodes
-            >>> print(topology['edges'])  # List of dependency edges
-        """
-        # Build nodes from task_configs
-        nodes = [
-            {
-                'id': tc.task_id,
-                'type': tc.task_type,
-                'config': tc.config,
-            }
-            for tc in self._workflow.task_configs
-        ]
-        
-        # Build edges from links
-        edges = [
-            {
-                'source': link.source,
-                'target': link.target,
-            }
-            for link in self._workflow.links
-        ]
-        
-        return {
-            'nodes': nodes,
-            'edges': edges,
-            'metadata': {
-                'id': self._workflow.workflow_id,
-                'name': self._workflow.name,
-            }
-        }
-
-    def get_execution_plan(self, targets: List[str] | None = None) -> List[str]:
-        """Get execution order for specified targets.
-        
-        Returns a list of task IDs in topological order (execution order).
-        
-        Args:
-            targets: Optional list of target task IDs to execute.
-                    If None, returns execution order for all tasks.
-        
-        Returns:
-            List of task IDs in execution order
-            
-        Example:
-            >>> plan = compiled.get_execution_plan()
-            >>> print(plan)  # ['task1', 'task2', 'task3']
-        """
-        # Build adjacency list and in-degree map
-        adj, in_degree = self.get_dependency_graph()
-        
-        # If no targets specified, use all tasks
-        if targets is None:
-            targets = list(in_degree.keys())
-        else:
-            missing = [task_id for task_id in targets if task_id not in in_degree]
-            if missing:
-                missing_list = ", ".join(missing)
-                raise ValueError(f"Unknown target task IDs: {missing_list}")
-        
-        # Topological sort using Kahn's algorithm
-        from collections import deque
-        
-        # Find all tasks needed for targets (reverse topological traversal)
-        needed = set()
-        queue = deque(targets)
-        while queue:
-            task_id = queue.popleft()
-            if task_id in needed:
-                continue
-            needed.add(task_id)
-            # Add all dependencies
-            for node_id, neighbors in adj.items():
-                if task_id in neighbors:
-                    queue.append(node_id)
-        
-        # Topological sort on needed tasks
-        in_deg = {k: v for k, v in in_degree.items() if k in needed}
-        queue = deque([k for k in needed if in_deg[k] == 0])
-        result = []
-        
-        while queue:
-            task_id = queue.popleft()
-            result.append(task_id)
-            
-            for neighbor in adj.get(task_id, []):
-                if neighbor in needed:
-                    in_deg[neighbor] -= 1
-                    if in_deg[neighbor] == 0:
-                        queue.append(neighbor)
-        
-        return result
-    
-    def get_dependency_graph(self) -> tuple[dict[str, list[str]], dict[str, int]]:
-        """Get dependency graph (adjacency list and in-degree map).
-
-        Returns:
-            Tuple of (adjacency_list, in_degree_map)
-        """
-        topology = self.get_topology()
-
-        adj: dict[str, list[str]] = {}
-        in_degree: dict[str, int] = {}
-
-        for node in topology['nodes']:
-            node_id = node['id']
-            adj[node_id] = []
-            in_degree[node_id] = 0
-
-        for edge in topology['edges']:
-            source = edge['source']
-            target = edge['target']
-            adj[source].append(target)
-            in_degree[target] += 1
-
-        return adj, in_degree
-
-    def get_task_types(self) -> dict[str, TaskExecutionType]:
-        """Get task execution types.
-
-        Returns:
-            Dict mapping task_id to TaskExecutionType
-        """
-        return self._task_types
-
-    def get_channels(self) -> dict[str, Any]:
-        """Get channel configurations.
-
-        Returns:
-            Dict of channel configurations
-        """
-        return self._channels
-
-    def has_actors(self) -> bool:
-        """Check if workflow contains any Actor tasks.
-
-        Returns:
-            True if workflow has at least one Actor task
-        """
-        return TaskExecutionType.ACTOR in self._task_types.values()
-
-
-
-class WorkflowCompiler:
-    """Compiles and validates workflows with a clean OOP API.
-    
-    This class provides the main entry point for workflow compilation.
-    It accepts Workflow objects and returns a CompiledWorkflow with 
-    high-level access methods.
-    
-    Example:
-        >>> compiler = WorkflowCompiler()
-        >>> compiled = compiler.compile(workflow)
-        >>> topology = compiled.get_topology()
-        >>> plan = compiled.get_execution_plan()
-    """
-
-    def __init__(self, optimize: bool = True):
-        """Initialize the compiler.
-        
-        Args:
-            optimize: Whether to apply optimization passes (reserved for future use)
-        """
-        self.optimize = optimize
-
-    def compile(self, workflow: Workflow) -> CompiledWorkflow:
-        """Compile a workflow.
-
-        Validates the workflow and returns a CompiledWorkflow with
-        high-level access methods. Detects Actor tasks via return type
-        inspection and allocates message channels.
-
-        Args:
-            workflow: Workflow to compile
-
-        Returns:
-            CompiledWorkflow with high-level API
-
-        Raises:
-            ValueError: If workflow validation fails
-
-        Example:
-            >>> workflow = Workflow.from_tasks(tasks, links)
-            >>> compiled = compiler.compile(workflow)
-        """
-        # Get task instances for type detection
-        task_map = {task.task_id: task for task in workflow.get_tasks()}
-
-        # Detect task types via return type inspection
-        task_types = {}
-        for task_id, task in task_map.items():
-            task_types[task_id] = self._detect_task_type(task)
-
-        # Basic validation (this auto-generates Link mappings)
-        self._validate_workflow(workflow)
-
-        # Allocate channels for actors (after validation populates mappings)
-        channels = self._allocate_channels(workflow, task_types)
-
-        # Return compiled workflow with type info
-        return CompiledWorkflow(workflow, task_types, channels)
-    
-    def _validate_workflow(self, workflow: Workflow) -> None:
-        """Validate workflow structure.
-        
-        Args:
-            workflow: Workflow to validate
-            
-        Raises:
-            ValueError: If validation fails
-        """
-        # Check for duplicate task IDs
-        task_ids = [tc.task_id for tc in workflow.task_configs]
-        if len(task_ids) != len(set(task_ids)):
-            raise ValueError("Duplicate task IDs found in workflow")
-        
-        # Check that all links reference valid tasks
-        task_id_set = set(task_ids)
-        for link in workflow.links:
-            if link.source not in task_id_set:
-                raise ValueError(f"Link references unknown source task: {link.source}")
-            if link.target not in task_id_set:
-                raise ValueError(f"Link references unknown target task: {link.target}")
-
-        # Load tasks for validation and auto-mapping
-        task_map = {task.task_id: task for task in workflow.get_tasks()}
-
-        # Auto-generate mappings and validate
-        for link in workflow.links:
-            source_task = task_map.get(link.source)
-            target_task = task_map.get(link.target)
-            if source_task is None or target_task is None:
-                raise ValueError(
-                    f"Link references missing task instances: {link.source} -> {link.target}"
-                )
-
-            # Check if either end is an Actor (Actors use dynamic channels)
-            from ..task import Actor
-            source_is_actor = isinstance(source_task, Actor)
-            target_is_actor = isinstance(target_task, Actor)
-
-            # For Actors, inputs/outputs are optional (channels are dynamic)
-            if not source_is_actor and not source_task.outputs:
-                raise ValueError(
-                    f"Task '{link.source}' must declare outputs for link validation"
-                )
-            if not target_is_actor and not target_task.inputs:
-                raise ValueError(
-                    f"Task '{link.target}' must declare inputs for link validation"
-                )
-
-            # Auto-generate mapping if not provided
-            if link.mapping is None:
-                if source_is_actor or target_is_actor:
-                    # For Actors, use a default channel name based on link
-                    # Format: use last part of source and target IDs
-                    source_name = link.source.split('_')[0].lower()
-                    target_name = link.target.split('_')[0].lower()
-                    channel_name = f"{source_name}_to_{target_name}"
-                    link.mapping = {channel_name: channel_name}
-                else:
-                    # For regular tasks, use input/output intersection
-                    auto_mapping = {}
-                    for output_name in source_task.outputs.keys():
-                        if output_name in target_task.inputs:
-                            auto_mapping[output_name] = output_name
-                    link.mapping = auto_mapping
-
-            # Validate mapping keys against declared inputs/outputs (only for non-Actors)
-            if link.mapping:
-                for output_name, input_name in link.mapping.items():
-                    if not source_is_actor and source_task.outputs and output_name not in source_task.outputs:
-                        raise ValueError(
-                            f"Link mapping references unknown output '{output_name}' "
-                            f"on task '{link.source}'"
-                        )
-                    if not target_is_actor and target_task.inputs and input_name not in target_task.inputs:
-                        raise ValueError(
-                            f"Link mapping references unknown input '{input_name}' "
-                            f"on task '{link.target}'"
-                        )
-        
-        # Check for cycles (simple DFS-based cycle detection)
-        # Note: Actors can have feedback loops, so only check for cycles in pure batch workflows
-        from ..task import Actor
-        has_any_actor = any(isinstance(task_map[tid], Actor) for tid in task_ids)
-
-        if not has_any_actor:
-            # Pure batch workflow - cycles not allowed
-            adj = {tid: [] for tid in task_ids}
-            for link in workflow.links:
-                adj[link.source].append(link.target)
-
-            visited = set()
-            rec_stack = set()
-
-            def has_cycle(node: str) -> bool:
-                visited.add(node)
-                rec_stack.add(node)
-
-                for neighbor in adj[node]:
-                    if neighbor not in visited:
-                        if has_cycle(neighbor):
-                            return True
-                    elif neighbor in rec_stack:
-                        return True
-
-                rec_stack.remove(node)
-                return False
-
-            for task_id in task_ids:
-                if task_id not in visited:
-                    if has_cycle(task_id):
-                        raise ValueError("Workflow contains cycles (not allowed for batch-only workflows)")
-
-    def _detect_task_type(self, task: Any) -> TaskExecutionType:
-        """Detect task execution type via return type annotation.
-
-        Args:
-            task: Task instance
-
-        Returns:
-            TaskExecutionType (BATCH or ACTOR)
-
-        Raises:
-            ValueError: If Actor missing AsyncGenerator return annotation
-        """
-        # Get execute method signature
-        sig = inspect.signature(task.execute)
-        return_annotation = sig.return_annotation
-
-        # Check if return type is AsyncGenerator
-        if return_annotation != inspect.Signature.empty:
-            origin = get_origin(return_annotation)
-            if origin is AsyncGenerator:
-                return TaskExecutionType.ACTOR
-
-        # Check if task is instance of Actor class
-        from ..task import Actor
-        if isinstance(task, Actor):
-            # Actor without proper return annotation - raise error
-            if return_annotation == inspect.Signature.empty or get_origin(return_annotation) is not AsyncGenerator:
-                raise ValueError(
-                    f"Actor task '{task.task_id}' must annotate execute() return type as "
-                    f"AsyncGenerator[None, dict[str, Any]]. Current annotation: {return_annotation}"
-                )
-
-        return TaskExecutionType.BATCH
-
-    def _allocate_channels(self, workflow: Workflow, task_types: dict[str, TaskExecutionType]) -> dict[str, Any]:
-        """Allocate asyncio.Queue channels for actor links.
-
-        Args:
-            workflow: Workflow being compiled
-            task_types: Dict of task_id -> TaskExecutionType
-
-        Returns:
-            Dict of channel configurations
-        """
-        channels = {}
-
-        for link in workflow.links:
-            source_type = task_types.get(link.source, TaskExecutionType.BATCH)
-            target_type = task_types.get(link.target, TaskExecutionType.BATCH)
-
-            # Only create channels if at least one side is an Actor
-            if source_type == TaskExecutionType.ACTOR or target_type == TaskExecutionType.ACTOR:
-                channel_id = f"{link.source}_to_{link.target}"
-                channels[channel_id] = {
-                    'source': link.source,
-                    'target': link.target,
-                    'buffer_size': link.buffer_size,
-                    'channel_mapping': link.channels or {},
-                    'mapping': link.mapping or {},  # Include Link mapping for channel name routing
-                }
-
-        return channels
diff --git a/src/molexp/workflow/config.py b/src/molexp/workflow/config.py
deleted file mode 100644
index e9140289..00000000
--- a/src/molexp/workflow/config.py
+++ /dev/null
@@ -1,13 +0,0 @@
-"""Configuration utilities for nodes."""
-
-from pydantic import BaseModel
-
-
-class EmptyConfig(BaseModel):
-    """Empty configuration for nodes that don't require parameters.
-
-    This is used for nodes that are fully determined by their inputs
-    and don't need additional configuration.
-    """
-
-    model_config = {"frozen": True}
diff --git a/src/molexp/workflow/context.py b/src/molexp/workflow/context.py
new file mode 100644
index 00000000..6eea19d7
--- /dev/null
+++ b/src/molexp/workflow/context.py
@@ -0,0 +1,145 @@
+"""Execution contexts for workflow tasks and actors.
+
+``TaskContext`` is the **single object** every user-defined task receives.
+It bridges the workflow type system (state, deps, inputs) with optional
+workspace capabilities (artifacts, assets, checkpoints).
+
+When a workflow runs outside a workspace (pure computation mode), the
+workspace methods gracefully return ``None`` instead of raising.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Generic
+
+from molexp.config import ProfileConfig
+
+from .types import DepsT, InputT, StateT
+
+
+class TaskContext(Generic[StateT, DepsT, InputT]):
+    """Context passed to every ``Task.execute()``.
+
+    Workflow-side (always available):
+        - ``state``   — shared mutable workflow state
+        - ``deps``    — injected dependencies
+        - ``inputs``  — typed output from the upstream task
+        - ``config``  — active :class:`~molexp.config.ProfileConfig`
+
+    Workspace-side (available when ``run`` is provided):
+        - ``save_artifact()``
+        - ``get_artifact_path()``
+        - ``find_asset()``
+        - ``checkpoint()``
+        - ``set_result()`` / ``get_result()``
+    """
+
+    def __init__(
+        self,
+        state: StateT,
+        deps: DepsT,
+        inputs: InputT,
+        config: ProfileConfig | None = None,
+        run_context: Any | None = None,
+    ) -> None:
+        self._state = state
+        self._deps = deps
+        self._inputs = inputs
+        self._config = config if config is not None else ProfileConfig({}, name=None)
+        self._run_ctx = run_context  # workspace.run.RunContext or None
+
+    # ── Workflow-side properties ─────────────────────────────────────────
+
+    @property
+    def state(self) -> StateT:
+        """Shared mutable workflow state visible to all tasks."""
+        return self._state
+
+    @property
+    def deps(self) -> DepsT:
+        """Injected dependencies (workspace, external services, …)."""
+        return self._deps
+
+    @property
+    def inputs(self) -> InputT:
+        """Typed output from the upstream task (``None`` for root tasks)."""
+        return self._inputs
+
+    @property
+    def run_context(self) -> Any:
+        """Access the underlying RunContext (``None`` if no run attached)."""
+        return self._run_ctx
+
+    @property
+    def config(self) -> ProfileConfig:
+        """Active molcfg profile configuration (read-only mapping)."""
+        return self._config
+
+    # ── Workspace-side helpers ───────────────────────────────────────────
+    # These return None / no-op when running without a workspace Run.
+
+    def save_artifact(self, name: str, data: Any) -> Path | None:
+        """Persist an artifact to the run's artifact directory.
+
+        Returns the written path, or ``None`` if no run is attached.
+        """
+        if self._run_ctx is None:
+            return None
+        return self._run_ctx.save_artifact(name, data)
+
+    def get_artifact_path(self, name: str) -> Path | None:
+        """Return the path to a previously saved artifact."""
+        if self._run_ctx is None:
+            return None
+        return self._run_ctx.get_artifact_path(name)
+
+    def find_asset(self, name: str) -> Any:
+        """Search for an asset up the scope hierarchy.
+
+        Order: experiment -> project -> workspace.
+        Returns ``None`` if not found or no run is attached.
+        """
+        if self._run_ctx is None:
+            return None
+        return self._run_ctx.find_asset(name)
+
+    def checkpoint(self, name: str | None = None) -> str | None:
+        """Create a checkpoint of current execution state.
+
+        Returns the checkpoint ID, or ``None`` if no run is attached.
+        """
+        if self._run_ctx is None:
+            return None
+        return self._run_ctx.checkpoint(name)
+
+    def set_result(self, key: str, value: Any) -> None:
+        """Store a named result in the run context."""
+        if self._run_ctx is not None:
+            self._run_ctx.set_result(key, value)
+
+    def get_result(self, key: str) -> Any:
+        """Retrieve a previously stored result."""
+        if self._run_ctx is None:
+            return None
+        return self._run_ctx.get_result(key)
+
+
+class ActorContext(TaskContext[StateT, DepsT, InputT]):
+    """Extended context for streaming ``Actor`` tasks.
+
+    Adds async message-passing primitives on top of ``TaskContext``.
+    """
+
+    async def receive(self) -> InputT:
+        """Wait for the next message from upstream."""
+        if self._run_ctx is not None and hasattr(self._run_ctx, "receive"):
+            return await self._run_ctx.receive("input")
+        raise NotImplementedError("receive() requires a connected run context")
+
+    async def send(self, output: Any) -> None:
+        """Send a message to downstream actors."""
+        if self._run_ctx is not None and hasattr(self._run_ctx, "emit"):
+            await self._run_ctx.emit("output", output)
+            return
+        raise NotImplementedError("send() requires a connected run context")
diff --git a/src/molexp/workflow/control/__init__.py b/src/molexp/workflow/control/__init__.py
deleted file mode 100644
index b2bc6f17..00000000
--- a/src/molexp/workflow/control/__init__.py
+++ /dev/null
@@ -1,22 +0,0 @@
-"""Control flow nodes for workflow logic."""
-
-from .conditional import ConditionalConfig, ConditionalTask
-from .loop import (ForLoopConfig, ForLoopTask, LoopConfig, LoopTask,
-                   WhileLoopConfig, WhileLoopTask)
-from .map import MapConfig, MapTask
-from .reduce import ReduceConfig, ReduceTask
-
-__all__ = [
-    "MapTask",
-    "MapConfig",
-    "ReduceTask",
-    "ReduceConfig",
-    "ConditionalTask",
-    "ConditionalConfig",
-    "LoopTask",
-    "LoopConfig",
-    "WhileLoopTask",
-    "WhileLoopConfig",
-    "ForLoopTask",
-    "ForLoopConfig",
-]
diff --git a/src/molexp/workflow/control/__pycache__/__init__.cpython-312.pyc b/src/molexp/workflow/control/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index 15a43eac..00000000
Binary files a/src/molexp/workflow/control/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/control/__pycache__/conditional.cpython-312.pyc b/src/molexp/workflow/control/__pycache__/conditional.cpython-312.pyc
deleted file mode 100644
index e9aadbfc..00000000
Binary files a/src/molexp/workflow/control/__pycache__/conditional.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/control/__pycache__/loop.cpython-312.pyc b/src/molexp/workflow/control/__pycache__/loop.cpython-312.pyc
deleted file mode 100644
index 433f1ea4..00000000
Binary files a/src/molexp/workflow/control/__pycache__/loop.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/control/__pycache__/map.cpython-312.pyc b/src/molexp/workflow/control/__pycache__/map.cpython-312.pyc
deleted file mode 100644
index 46c651b5..00000000
Binary files a/src/molexp/workflow/control/__pycache__/map.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/control/__pycache__/parallel.cpython-312.pyc b/src/molexp/workflow/control/__pycache__/parallel.cpython-312.pyc
deleted file mode 100644
index 161de8a2..00000000
Binary files a/src/molexp/workflow/control/__pycache__/parallel.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/control/__pycache__/reduce.cpython-312.pyc b/src/molexp/workflow/control/__pycache__/reduce.cpython-312.pyc
deleted file mode 100644
index 43665a82..00000000
Binary files a/src/molexp/workflow/control/__pycache__/reduce.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/control/conditional.py b/src/molexp/workflow/control/conditional.py
deleted file mode 100644
index b1dba44e..00000000
--- a/src/molexp/workflow/control/conditional.py
+++ /dev/null
@@ -1,98 +0,0 @@
-"""Conditional task: Branch based on condition."""
-
-from __future__ import annotations
-
-from typing import Any, Callable
-
-from pydantic import BaseModel
-
-from ..config import EmptyConfig
-from ..task import Task
-from ..plugin.registry import register
-
-
-class ConditionalConfig(EmptyConfig):
-    """Configuration for ConditionalTask.
-
-    The branching logic is determined by the condition function
-    and tasks passed during initialization.
-    """
-
-    pass
-
-
-@register("control.conditional")
-class ConditionalTask(Task[ConditionalConfig, Any]):
-    """Execute one of two branches based on a runtime condition.
-
-    This task evaluates a condition function and executes either
-    the 'then' or 'else' branch, but not both (lazy evaluation).
-
-    Examples
-    --------
-    >>> def is_positive(x): return x > 0
-    >>> then_task = ProcessPositiveTask()
-    >>> else_task = ProcessNegativeTask()
-    >>> cond_task = ConditionalTask(
-    ...     condition_fn=is_positive,
-    ...     then_task=then_task,
-    ...     else_task=else_task
-    ... )
-    >>> result = cond_task(ctx=ctx, condition_input=value)
-    >>> output = result["result"]
-    """
-
-    config_type = ConditionalConfig
-    inputs = {"condition_input": Any}
-    outputs = {"result": Any}
-    replayable = False
-
-    def __init__(
-        self,
-        condition_fn: Callable[[Any], bool],
-        then_task: Task,
-        else_task: Task,
-    ):
-        """Initialize conditional task.
-
-        Parameters
-        ----------
-        condition_fn : Callable[[Any], bool]
-            Function that returns True/False
-        then_task : Task
-            Task to execute if condition is True
-        else_task : Task
-            Task to execute if condition is False
-        """
-        super().__init__()
-        self.condition_fn = condition_fn
-        self.then_task = then_task
-        self.else_task = else_task
-
-    def execute(self, ctx=None, **inputs) -> dict[str, Any]:
-        """Evaluate condition and execute selected branch.
-
-        Parameters
-        ----------
-        ctx : Any | None
-            Execution context
-        **inputs : Any
-            Must contain 'condition_input'
-
-        Returns
-        -------
-        dict[str, Any]
-            Dict with 'result' key from selected branch
-        """
-        condition_input = inputs.get("condition_input")
-        
-        condition_result = self.condition_fn(condition_input)
-        selected_task = self.then_task if condition_result else self.else_task
-
-        # Execute selected branch
-        if isinstance(condition_input, dict):
-            result = selected_task(ctx=ctx, **condition_input)
-        else:
-            result = selected_task(ctx=ctx, input=condition_input)
-        
-        return {"result": result}
diff --git a/src/molexp/workflow/control/loop.py b/src/molexp/workflow/control/loop.py
deleted file mode 100644
index 6225812a..00000000
--- a/src/molexp/workflow/control/loop.py
+++ /dev/null
@@ -1,249 +0,0 @@
-"""Loop nodes: Iterative execution patterns."""
-
-from __future__ import annotations
-
-from typing import Any, Callable
-import warnings
-
-from pydantic import BaseModel, Field
-
-from ..config import EmptyConfig
-from ..task import Task
-from ..plugin.registry import register
-
-
-class LoopConfig(BaseModel):
-    """Configuration for basic loop task.
-
-    Attributes
-    ----------
-    iterations : int
-        Number of times to repeat
-    """
-
-    iterations: int = Field(..., ge=1, description="Number of iterations")
-
-
-@register("control.loop")
-class LoopTask(Task[LoopConfig, Any]):
-    """Repeat a task a fixed number of times.
-
-    Each iteration feeds its output to the next iteration.
-
-    Examples
-    --------
-    >>> body_task = IncrementTask()
-    >>> loop_task = LoopTask(body_task=body_task, iterations=10)
-    >>> result = loop_task(ctx=ctx, initial=0)
-    >>> final_value = result["result"]
-    """
-
-    config_type = LoopConfig
-    inputs = {"initial": Any}
-    outputs = {"result": Any}
-    replayable = False
-
-    def __init__(self, body_task: Task, iterations: int):
-        """Initialize loop task.
-
-        Parameters
-        ----------
-        body_task : Task
-            Task to execute on each iteration
-        iterations : int
-            Number of iterations
-        """
-        super().__init__(iterations=iterations)
-        self.body_task = body_task
-
-    def execute(self, ctx=None, **inputs) -> dict[str, Any]:
-        """Execute loop for specified iterations.
-
-        Parameters
-        ----------
-        ctx : Any | None
-            Execution context
-        **inputs : Any
-            Must contain 'initial' value
-
-        Returns
-        -------
-        dict[str, Any]
-            Dict with 'result' key containing final value
-        """
-        value = inputs.get("initial")
-        
-        for _ in range(self.config.iterations):
-            if isinstance(value, dict):
-                result = self.body_task(ctx=ctx, **value)
-            else:
-                result = self.body_task(ctx=ctx, value=value)
-            # Extract value from result dict
-            value = result.get("result", result)
-        
-        return {"result": value}
-
-
-class WhileLoopConfig(BaseModel):
-    """Configuration for while loop task.
-
-    Attributes
-    ----------
-    max_iterations : int
-        Safety limit to prevent infinite loops
-    """
-
-    max_iterations: int = Field(
-        1000, ge=1, description="Maximum iterations (safety limit)"
-    )
-
-
-@register("control.while_loop")
-class WhileLoopTask(Task[WhileLoopConfig, Any]):
-    """Loop until a condition becomes False.
-
-    Examples
-    --------
-    >>> def not_converged(x): return abs(x - 1.0) > 0.01
-    >>> body_task = OptimizeStepTask()
-    >>> loop_task = WhileLoopTask(
-    ...     condition_fn=not_converged,
-    ...     body_task=body_task,
-    ...     max_iterations=100
-    ... )
-    >>> result = loop_task(ctx=ctx, initial=0.0)
-    >>> final_value = result["result"]
-    """
-
-    config_type = WhileLoopConfig
-    inputs = {"initial": Any}
-    outputs = {"result": Any}
-    replayable = False
-
-    def __init__(
-        self,
-        body_task: Task,
-        condition_fn: Callable[[Any], bool],
-        max_iterations: int = 1000,
-    ):
-        """Initialize while loop task.
-
-        Parameters
-        ----------
-        body_task : Task
-            Task to execute on each iteration
-        condition_fn : Callable[[Any], bool]
-            Function that returns True to continue
-        max_iterations : int
-            Safety limit
-        """
-        super().__init__(max_iterations=max_iterations)
-        self.condition_fn = condition_fn
-        self.body_task = body_task
-
-    def execute(self, ctx=None, **inputs) -> dict[str, Any]:
-        """Execute loop until condition is False.
-
-        Parameters
-        ----------
-        ctx : Any | None
-            Execution context
-        **inputs : Any
-            Must contain 'initial' value
-
-        Returns
-        -------
-        dict[str, Any]
-            Dict with 'result' key containing final value
-        """
-        value = inputs.get("initial")
-        iteration = 0
-
-        while iteration < self.config.max_iterations:
-            if not self.condition_fn(value):
-                break
-
-            if isinstance(value, dict):
-                result = self.body_task(ctx=ctx, **value)
-            else:
-                result = self.body_task(ctx=ctx, value=value)
-            
-            value = result.get("result", result)
-            iteration += 1
-
-        if iteration >= self.config.max_iterations:
-            warnings.warn(
-                f"WhileLoopTask reached max iterations ({self.config.max_iterations})",
-                RuntimeWarning,
-            )
-
-        return {"result": value}
-
-
-class ForLoopConfig(BaseModel):
-    """Configuration for for loop task.
-
-    Attributes
-    ----------
-    iterations : int
-        Number of iterations
-    """
-
-    iterations: int = Field(..., ge=1, description="Number of iterations")
-
-
-@register("control.for_loop")
-class ForLoopTask(Task[ForLoopConfig, Any]):
-    """Loop with index access.
-
-    The body task receives value and index as inputs.
-
-    Examples
-    --------
-    >>> def accumulate(state, i): return state + i
-    >>> body_task = AccumulateTask()
-    >>> loop_task = ForLoopTask(body_task=body_task, iterations=10)
-    >>> result = loop_task(ctx=ctx, initial=0)
-    >>> final_value = result["result"]
-    """
-
-    config_type = ForLoopConfig
-    inputs = {"initial": Any}
-    outputs = {"result": Any}
-    replayable = False
-
-    def __init__(self, body_task: Task, iterations: int):
-        """Initialize for loop task.
-
-        Parameters
-        ----------
-        body_task : Task
-            Task that takes value and index as inputs
-        iterations : int
-            Number of iterations
-        """
-        super().__init__(iterations=iterations)
-        self.body_task = body_task
-
-    def execute(self, ctx=None, **inputs) -> dict[str, Any]:
-        """Execute loop with index.
-
-        Parameters
-        ----------
-        ctx : Any | None
-            Execution context
-        **inputs : Any
-            Must contain 'initial' value
-
-        Returns
-        -------
-        dict[str, Any]
-            Dict with 'result' key containing final value
-        """
-        value = inputs.get("initial")
-        
-        for i in range(self.config.iterations):
-            result = self.body_task(ctx=ctx, value=value, index=i)
-            value = result.get("result", result)
-        
-        return {"result": value}
diff --git a/src/molexp/workflow/control/map.py b/src/molexp/workflow/control/map.py
deleted file mode 100644
index 25e445d6..00000000
--- a/src/molexp/workflow/control/map.py
+++ /dev/null
@@ -1,82 +0,0 @@
-"""Map task: Apply operation to each element of a collection."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from pydantic import BaseModel
-
-from ..task import Task
-from ..plugin.registry import register
-
-
-class MapConfig(BaseModel):
-    """Configuration for MapTask."""
-
-    map_over: str = "items"  # The input key to iterate over
-
-
-@register("control.map")
-class MapTask(Task[MapConfig, list[Any]]):
-    """Apply a task to each element of an iterable input.
-
-    This is a control flow task that enables iteration in workflows.
-    The workflow engine handles parallelism.
-
-    Examples:
-        >>> map_task = MapTask(base_task=some_task, map_over="params")
-        >>> result = map_task(ctx=ctx, params=[...], other_input=value)
-    """
-
-    config_type = MapConfig
-    inputs = {}
-    outputs = {}
-    replayable = False
-
-    def __init__(
-        self,
-        base_task: Task,
-        /,
-        map_over: str = "items",
-        static_inputs: list[str] | None = None,
-        **config_kwargs: Any
-    ):
-        """Initialize MapTask.
-
-        Args:
-            base_task: The task to apply to each element (positional-only)
-            map_over: The input key to iterate over
-            static_inputs: Input names that come from workflow (not from items).
-                          If None, assumes all base_task inputs come from items.
-            **config_kwargs: Additional config arguments
-        """
-        super().__init__(map_over=map_over, **config_kwargs)
-        self.base_task = base_task
-
-        # MapTask inputs = iterable + static inputs
-        # Dynamic inputs (from items) are NOT in MapTask.inputs
-        self.inputs = {map_over: list}
-        if static_inputs:
-            for input_name in static_inputs:
-                if input_name in base_task.inputs:
-                    self.inputs[input_name] = base_task.inputs[input_name]
-
-        self.outputs = base_task.outputs.copy() if base_task.outputs else {}
-
-    def execute(self, ctx=None, **inputs) -> dict[str, Any]:
-        """Apply base_task to each element."""
-        iterable = inputs.pop(self.config.map_over, [])
-        # Remaining inputs are passed to each base_task call
-        static_inputs = inputs
-
-        results: list[Any] = []
-        for item in iterable:
-            if isinstance(item, dict):
-                # Merge static inputs with item
-                merged_inputs = {**static_inputs, **item}
-                result = self.base_task(ctx=ctx, **merged_inputs)
-            else:
-                result = self.base_task(ctx=ctx, value=item, **static_inputs)
-            results.append(result)
-
-        return {"results": results}
diff --git a/src/molexp/workflow/control/reduce.py b/src/molexp/workflow/control/reduce.py
deleted file mode 100644
index 8cd2426d..00000000
--- a/src/molexp/workflow/control/reduce.py
+++ /dev/null
@@ -1,82 +0,0 @@
-"""Reduce task: Aggregate collection using a reduction strategy."""
-
-from __future__ import annotations
-
-from typing import Any, Literal
-
-from pydantic import BaseModel, Field
-
-from ..task import Task
-from ..plugin.registry import register
-
-
-class ReduceConfig(BaseModel):
-    """Configuration for ReduceTask.
-
-    Attributes:
-        method: Reduction method: "sum", "mean", "max", "min", "concat"
-    """
-
-    method: Literal["sum", "mean", "max", "min", "concat"] = Field(
-        ..., description="Reduction method to apply"
-    )
-
-
-@register("control.reduce")
-class ReduceTask(Task[ReduceConfig, Any]):
-    """Reduce a collection to a single value using a strategy.
-
-    Configuration (method) must be provided at construction.
-
-    Examples:
-        >>> reduce_task = ReduceTask(method="sum")
-        >>> result = reduce_task(ctx=ctx, collection=data)
-        >>> total = result["result"]
-        >>>
-        >>> avg_task = ReduceTask(method="mean")
-        >>> result = avg_task(ctx=ctx, collection=data)
-        >>> average = result["result"]
-    """
-
-    config_type = ReduceConfig
-    inputs = {"collection": list}
-    outputs = {"result": Any}
-
-    def execute(self, ctx=None, **inputs) -> dict[str, Any]:
-        """Reduce collection using self.config.method.
-
-        Args:
-            ctx: Execution context
-            **inputs: Must contain 'collection' (list)
-
-        Returns:
-            Dict with 'result' key containing reduced value
-
-        Raises:
-            ValueError: If method is unknown
-        """
-        collection = inputs.get("collection", [])
-        data = list(collection)
-
-        if self.config.method == "sum":
-            result = sum(data)
-        elif self.config.method == "mean":
-            result = sum(data) / len(data) if data else 0
-        elif self.config.method == "max":
-            result = max(data) if data else None
-        elif self.config.method == "min":
-            result = min(data) if data else None
-        elif self.config.method == "concat":
-            # Concatenate strings or lists
-            if not data:
-                result = []
-            elif isinstance(data[0], str):
-                result = "".join(data)
-            else:
-                result = []
-                for item in data:
-                    result.extend(item)
-        else:
-            raise ValueError(f"Unknown reduce method: {self.config.method}")
-        
-        return {"result": result}
diff --git a/src/molexp/workflow/engine/__init__.py b/src/molexp/workflow/engine/__init__.py
deleted file mode 100644
index 0cc4010e..00000000
--- a/src/molexp/workflow/engine/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-"""Workflow execution engine."""
-
-from .engine import WorkflowEngine
-
-__all__ = [
-    "WorkflowEngine",
-]
diff --git a/src/molexp/workflow/engine/engine.py b/src/molexp/workflow/engine/engine.py
deleted file mode 100644
index 4417d289..00000000
--- a/src/molexp/workflow/engine/engine.py
+++ /dev/null
@@ -1,931 +0,0 @@
-"""Workflow execution engine with hybrid execution and hot reconfiguration.
-
-This module implements the WorkflowEngine class which orchestrates workflow execution
-with automatic mode selection based on task types:
-
-- **Pure Batch Mode**: Traditional ThreadPoolExecutor-based execution for workflows
-  containing only batch tasks. Provides fast, dependency-ordered execution.
-
-- **Hybrid Mode**: Asyncio-based execution for workflows containing Actors. Supports
-  concurrent actor execution with message passing while also handling batch tasks.
-
-Key Features:
-    - Automatic execution mode detection via type inspection
-    - Hot reconfiguration: update actor config during execution
-    - Message channel management with backpressure control
-    - Failure propagation with detailed error reporting
-    - External task submission via submitor protocol
-
-Example:
-    Basic workflow execution::
-
-        engine = WorkflowEngine(workflow)
-        with run.start() as run_ctx:
-            results = engine.execute(run_context=run_ctx)
-
-    Hot reconfiguration::
-
-        engine.update_actor_config('sampler_123', {'threshold': 0.3})
-
-    Multi-actor workflow::
-
-        workflow = Workflow.from_tasks([actorA, actorB, actorC], links)
-        engine = WorkflowEngine(workflow)
-        results = engine.execute(run_context=run_ctx)
-"""
-
-import asyncio
-import traceback
-from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
-from typing_extensions import Any
-from rich.console import Console
-
-from mollog import get_logger
-
-logger = get_logger(__name__)
-console = Console()
-
-from molexp.workflow.execution_type import TaskExecutionType
-from molexp.workflow.status import TaskStatus
-from molexp.workflow.task import Task, Actor
-from molexp.workflow.workflow import Workflow
-from molexp.workspace import Context, RunStatus, RunContext
-from molexp.workflow.compiler import WorkflowCompiler
-
-
-# ============================================================================
-# Execution context is now part of Run.context
-# Helper functions for execution context management
-def mark_succeeded(context: "Context", task_id: str, result: dict[str, Any]) -> None:
-    """Mark task as succeeded and store result."""
-    context.tasks[task_id] = TaskStatus.SUCCEEDED
-    context.results[task_id] = result
-
-
-def mark_failed(context: "Context", task_id: str, error: Exception) -> None:
-    """Mark task as failed and store error."""
-    context.tasks[task_id] = TaskStatus.FAILED
-    # Store both error message and full traceback
-    context.errors[task_id] = {
-        "message": str(error),
-        "type": type(error).__name__,
-        "traceback": traceback.format_exc()
-    }
-
-
-def mark_cancelled(context: "Context", task_id: str) -> None:
-    """Mark task as cancelled."""
-    context.tasks[task_id] = TaskStatus.CANCELLED
-    context.errors[task_id] = {
-        "message": "Cancelled due to upstream failure",
-        "type": "Cancelled",
-        "traceback": None
-    }
-
-
-def is_failed_or_cancelled(context: "Context", task_id: str) -> bool:
-    """Check if task has failed or been cancelled."""
-    status = context.tasks.get(task_id)
-    return status in (TaskStatus.FAILED, TaskStatus.CANCELLED)
-
-
-def print_task_error(task_id: str, error_info: dict[str, Any]) -> None:
-    """Print task error with background colors but no borders for easy copying."""
-    console.print()
-    
-    # Print error header with background color
-    console.print(f"[bold white on red] ❌ TASK FAILED: {task_id} [/bold white on red]")
-    console.print(f"[bold red]Error Type:[/bold red] {error_info['type']}")
-    console.print(f"[bold red]Message:[/bold red] {error_info['message']}")
-    
-    # Print traceback with light red background
-    if error_info.get('traceback'):
-        console.print()
-        console.print("[bold yellow]Full Traceback:[/bold yellow]")
-        
-        # Split traceback into lines and print each with light red background
-        traceback_lines = error_info['traceback'].strip().split('\n')
-        for line in traceback_lines:
-            # Use light red background for the entire traceback
-            console.print(f"[on rgb(60,20,20)]{line}[/on rgb(60,20,20)]")
-    console.print()
-# ============================================================================
-# Workflow Engine
-# ============================================================================
-
-
-class WorkflowEngine:
-    """Executes compiled workflows with parallel execution and failure propagation.
-
-    The engine:
-    - Accepts a Workflow object at construction
-    - Compiles it using WorkflowCompiler
-    - Executes tasks with named inputs/outputs
-    - Supports parallel execution of independent tasks
-    - Propagates failures to dependent tasks
-    """
-
-    def __init__(
-        self,
-        workflow: "Workflow",
-        max_workers: int = 4,
-        task_timeout: float | None = None,
-    ) -> None:
-        """Initialize the workflow engine.
-
-        Args:
-            workflow: Workflow object to execute
-            max_workers: Maximum number of concurrent task executions
-            task_timeout: Timeout in seconds for each task (None = no timeout)
-        """
-        self.workflow = workflow
-        self.max_workers = max_workers
-        self.task_timeout = task_timeout
-
-        # Compile workflow
-        self.compiled = WorkflowCompiler().compile(workflow)
-
-        # Get dependency graph from compiled workflow
-        self._adj, self._in_degree_template = self.compiled.get_dependency_graph()
-
-        # Get tasks from workflow (will use cached _tasks if available)
-        # Import registry here to avoid circular dependency
-        tasks = workflow.get_tasks()
-
-        # Build task map from workflow
-        self._task_map = {task.task_id: task for task in tasks}
-        self._thread_executor: ThreadPoolExecutor | None = None
-
-        # Submitor registry for external task submission
-        self._submitors: dict[str, Any] = {}  # backend_name -> submitor instance
-
-    def _compute_subgraph(self, phases: list[str] | None = None) -> tuple[set[str], dict[str, int]]:
-        """Compute the workflow graph to execute, optionally filtered by phase.
-
-        Args:
-            phases: If provided, only tasks whose phase is in this list
-                    (or whose phase is None) will be included.
-
-        Returns:
-            Tuple of (tasks_to_execute, in_degree_map)
-        """
-        if phases is None:
-            tasks_to_execute = set(self._task_map.keys())
-        else:
-            # Build a task_id -> phase lookup from task_configs
-            phase_map = {tc.task_id: tc.phase for tc in self.workflow.task_configs}
-            tasks_to_execute = {
-                task_id for task_id in self._task_map
-                if phase_map.get(task_id) is None or phase_map.get(task_id) in phases
-            }
-
-        # Build in_degree map counting only edges within the subgraph
-        in_degree = {task_id: 0 for task_id in tasks_to_execute}
-        for task_id in tasks_to_execute:
-            for link in self.workflow.links:
-                if link.target == task_id and link.source in tasks_to_execute:
-                    in_degree[task_id] += 1
-
-        return tasks_to_execute, in_degree
-
-    def execute(
-        self,
-        run_context: "RunContext",
-        phases: list[str] | None = None,
-        **kwargs: Any,
-    ) -> dict[str, dict[str, Any]]:
-        """Execute the workflow with RunContext.
-
-        Automatically detects Actor tasks and uses hybrid execution mode
-        with asyncio event loop. Pure batch workflows use the fast path.
-
-        Args:
-            run_context: RunContext wrapper (not pure Context)
-            phases: If provided, only execute tasks whose phase matches
-                    (or tasks with phase=None). Pass None to run all tasks.
-            **kwargs: Flat keyword arguments that tasks can pick from based on their input requirements
-
-        Returns:
-            Dict mapping task IDs to their output dicts
-        """
-        self.run_context = run_context
-        self._phases = phases
-
-        # Stage 1: Before execution - enrich context with workflow
-        self._before_execute()
-
-        try:
-            # Stage 2: Detect actors and choose execution path
-            if self.compiled.has_actors():
-                # Hybrid execution with asyncio for actors
-                logger.debug("Detected Actor tasks - using hybrid execution mode")
-                results = self._execute_hybrid(**kwargs)
-            else:
-                # Pure batch - fast path with ThreadPoolExecutor
-                results = self._execute(**kwargs)
-
-            # Stage 3: After execution (success)
-            self._after_execute(results, success=True)
-
-            return results
-
-        except Exception as e:
-            # Stage 3: After execution (failure)
-            self._after_execute(None, success=False, error=e)
-            raise
-
-    def update_actor_config(self, actor_id: str, config_updates: dict[str, Any]) -> None:
-        """Update actor configuration during execution (hot reconfiguration).
-
-        This method enables updating actor config while the workflow is running.
-        Actors check self.config on each iteration, so changes take effect
-        immediately on the next iteration.
-
-        **Thread Safety:** Safe in asyncio (single-threaded event loop).
-        **Stateless Pattern:** All actor state should be in config for this to work.
-
-        Args:
-            actor_id: Task ID of the actor to update
-            config_updates: Dict of config fields to update (partial updates supported)
-
-        Raises:
-            KeyError: If actor_id not found
-            ValueError: If config validation fails
-            TypeError: If task is not an Actor
-
-        Example:
-            >>> # Update sampling threshold during execution
-            >>> engine.update_actor_config('sampler_123', {'threshold': 0.2})
-            >>>
-            >>> # Update multiple fields
-            >>> engine.update_actor_config('trainer_456', {
-            ...     'learning_rate': 0.001,
-            ...     'batch_size': 64
-            ... })
-        """
-        from ..task import Actor
-
-        # Get actor from task map
-        if actor_id not in self._task_map:
-            raise KeyError(f"Actor '{actor_id}' not found in workflow")
-
-        actor = self._task_map[actor_id]
-
-        # Verify it's an Actor
-        if not isinstance(actor, Actor):
-            raise TypeError(f"Task '{actor_id}' is not an Actor (type: {type(actor).__name__})")
-
-        # Create updated config by merging with existing config
-        current_config_dict = actor.config.model_dump()
-        current_config_dict.update(config_updates)
-
-        # Validate new config against actor's config_type schema
-        new_config = actor.config_type(**current_config_dict)
-
-        # Update config in-place (thread-safe in asyncio)
-        actor.config = new_config
-
-        logger.info(f"Updated config for actor {actor_id}: {config_updates}")
-
-        # TODO: Save to workflow metadata for persistence
-        # TODO: Store in config history if tracking enabled
-
-    def _before_execute(self):
-        """Enrich context with workflow information and load persisted results."""
-        # Use RunContext method to set workflow
-        self.run_context.set_workflow(self.workflow)
-
-        # Load persisted results from run.json (enables cross-phase input resolution)
-        self._load_persisted_results()
-
-        # Initialize task statuses in internal context
-        for task_config in self.workflow.task_configs:
-            self.run_context.context.tasks[task_config.task_id] = TaskStatus.PENDING
-
-        # Save updated context
-        self.run_context._save_context()
-        self._init_execution_metadata()
-
-    def _load_persisted_results(self):
-        """Load previously persisted context.results from run.json."""
-        import json as _json
-
-        run_json = self.run_context.work_dir / "run.json"
-        if not run_json.exists() or run_json.stat().st_size == 0:
-            return
-
-        with open(run_json, "r") as f:
-            data = _json.load(f)
-        persisted_results = data.get("context", {}).get("results", {})
-        if persisted_results:
-            # Merge: persisted results are available but won't overwrite fresh ones
-            for key, value in persisted_results.items():
-                if key not in self.run_context.context.results:
-                    self.run_context.context.results[key] = value
-    
-    def _execute(self, **kwargs: Any) -> dict[str, dict[str, Any]]:
-        """Execute workflow tasks.
-        
-        Args:
-            **kwargs: Flat keyword arguments for task dependency injection
-            
-        Returns:
-            Dict mapping task IDs to their output dicts
-        """
-        # Access internal context for execution
-        context = self.run_context.context
-        
-        # Set context status to RUNNING
-        context.status["run"] = RunStatus.RUNNING
-        
-        # Compute workflow graph to execute (filtered by phase if set)
-        tasks_to_execute, in_degree = self._compute_subgraph(self._phases)
-        
-        # Initialize execution queue with tasks that have no dependencies in subgraph
-        queue = [task_id for task_id in tasks_to_execute if in_degree[task_id] == 0]
-        active_futures: dict[Future, str] = {}
-        
-        logger.info(f"Starting workflow {self.workflow.workflow_id}, executing {len(tasks_to_execute)} tasks")
-        
-        # Create executor
-        self._thread_executor = ThreadPoolExecutor(max_workers=self.max_workers)
-        
-        try:
-            while queue or active_futures:
-                # Submit ready tasks
-                while queue:
-                    task_id = queue.pop(0)
-                    
-                    # Skip if already cancelled
-                    if is_failed_or_cancelled(context, task_id):
-                        continue
-                    
-                    task = self._task_map[task_id]
-                    context.tasks[task_id] = TaskStatus.RUNNING
-                    
-                    # Resolve inputs from upstream tasks and global kwargs
-                    task_inputs = self._resolve_inputs(task_id, kwargs, context)
-                    self._validate_inputs(task_id, task_inputs)
-                    
-                    # Submit for execution
-                    future = self._thread_executor.submit(
-                        self._execute_task,
-                        task_id,
-                        task,
-                        task_inputs,
-                    )
-                    active_futures[future] = task_id
-                
-                # Wait for any completion
-                if not active_futures:
-                    break
-                
-                done, _ = wait(active_futures.keys(), return_when=FIRST_COMPLETED)
-                
-                for future in done:
-                    task_id = active_futures.pop(future)
-                    result = future.result(timeout=self.task_timeout)
-                    mark_succeeded(context, task_id, result)
-                    logger.debug(f"Task {task_id} succeeded")
-
-                    # Unlock dependents (only those in subgraph)
-                    for neighbor in self._adj[task_id]:
-                        if neighbor in tasks_to_execute:
-                            in_degree[neighbor] -= 1
-                            if in_degree[neighbor] == 0:
-                                queue.append(neighbor)
-            
-            # Return results
-            return context.results
-        
-        finally:
-            self._thread_executor.shutdown(wait=True)
-            self._thread_executor = None
-    
-    def _after_execute(self, results: dict | None, success: bool, error: Exception | None = None):
-        """Update context with execution results.
-        
-        Args:
-            results: Execution results (None if failed)
-            success: Whether execution succeeded
-            error: Exception if failed
-        """
-        context = self.run_context.context
-        
-        if success:
-            # Use RunContext method to bind results
-            if results:
-                for key, value in results.items():
-                    self.run_context.set_result(key, value)
-            
-            # Check if workflow succeeded or failed based on task statuses
-            has_failures = any(
-                status in (TaskStatus.FAILED, TaskStatus.CANCELLED)
-                for status in context.tasks.values()
-            )
-            
-            if has_failures:
-                context.status['run'] = RunStatus.FAILED
-                logger.error(f"Workflow {self.workflow.workflow_id} failed")
-            else:
-                context.status['run'] = RunStatus.SUCCEEDED
-                logger.debug(f"Workflow {self.workflow.workflow_id} succeeded")
-        else:
-            context.status['run'] = RunStatus.FAILED
-            if error:
-                context.errors['engine'] = {
-                    "type": type(error).__name__,
-                    "message": str(error)
-                }
-            logger.error(f"Workflow execution failed with error: {error}")
-        
-        # Save updated context
-        self.run_context._save_context()
-
-    def _init_execution_metadata(self) -> None:
-        """Initialize execution metadata in context."""
-        context = self.run_context.context
-        context.execution = {}
-
-    def register_submitor(
-        self,
-        name: str,
-        submitor: "SubmitorProtocol",
-    ) -> None:
-        """Register a submitor backend for task submission.
-
-        Args:
-            name: Backend name (e.g., "molq", "molq-slurm")
-            submitor: Submitor instance implementing SubmitorProtocol
-
-        Example:
-            >>> from molq.submit import get_submitor
-            >>> engine = WorkflowEngine(workflow)
-            >>> submitor = get_submitor("local", "local")
-            >>> engine.register_submitor("molq", submitor)
-        """
-        from molexp.workflow.submitor import SubmitorProtocol
-
-        # Validate submitor implements protocol
-        if not hasattr(submitor, "submit") or not hasattr(submitor, "query"):
-            raise TypeError(
-                f"Submitor must implement SubmitorProtocol (submit, query, cancel methods)"
-            )
-
-        self._submitors[name] = submitor
-        logger.info(f"Registered submitor '{name}': {submitor}")
-
-    def _get_submitor(self, backend: str) -> Any:
-        """Get registered submitor for backend name.
-
-        Args:
-            backend: Backend name
-
-        Returns:
-            Submitor instance
-
-        Raises:
-            ValueError: If backend not registered
-        """
-        if backend not in self._submitors:
-            raise ValueError(
-                f"Submitor backend '{backend}' not configured. "
-                f"Call engine.register_submitor('{backend}', submitor) first."
-            )
-        return self._submitors[backend]
-
-    def _execute_task(
-        self,
-        task_id: str,
-        task: Task,
-        task_inputs: dict[str, Any],
-    ) -> dict[str, Any]:
-        """Execute a task via execute() or submit() based on submittable attribute.
-
-        Args:
-            task_id: Task identifier
-            task: Task instance
-            task_inputs: Resolved input arguments
-
-        Returns:
-            Task outputs dict
-        """
-        # Dispatch based on submittable attribute
-        if task.submittable is None:
-            # Local execution
-            return task.execute(ctx=self.run_context, **task_inputs)
-        else:
-            # External submission
-            backend = task.submittable
-            submitor = self._get_submitor(backend)
-            return self._handle_generator_submission(
-                task, submitor, task_id, task_inputs
-            )
-
-    def _handle_generator_submission(
-        self,
-        task: Task,
-        submitor: "SubmitorProtocol",
-        task_id: str,
-        task_inputs: dict[str, Any],
-    ) -> dict[str, Any]:
-        """Handle generator-based task submission via submitor.
-
-        Args:
-            task: Task instance
-            submitor: Submitor implementing SubmitorProtocol
-            task_id: Task identifier
-            task_inputs: Task inputs
-
-        Returns:
-            Task outputs dict
-
-        Raises:
-            TypeError: If yielded value is not a JobSpec
-            RuntimeError: If submission fails
-        """
-        import time
-
-        generator = task.submit(ctx=self.run_context, **task_inputs)
-        submitted_jobs = []  # Track all submitted jobs for this task
-
-        job_spec = next(generator)
-        while True:
-            # Validate JobSpec (can be dict or Pydantic model)
-            if not isinstance(job_spec, (dict, object)):
-                raise TypeError(
-                    f"Task {task_id} yielded {type(job_spec)}, expected JobSpec"
-                )
-
-            # Extract execution spec to check blocking behavior
-            execution_spec = self._get_execution_spec(job_spec)
-            block = execution_spec.get("block", True) if isinstance(execution_spec, dict) else getattr(execution_spec, "block", True)
-
-            # Submit via submitor
-            logger.info(f"Submitting job for task {task_id} via {task.submittable}")
-            job_id = submitor.submit(job_spec)
-            logger.info(f"Job {job_id} submitted for task {task_id}")
-
-            # Track submission
-            submitted_jobs.append(job_id)
-
-            # Record submission in context.execution
-            if "submissions" not in self.run_context.context.execution:
-                self.run_context.context.execution["submissions"] = {}
-            if task_id not in self.run_context.context.execution["submissions"]:
-                self.run_context.context.execution["submissions"][task_id] = []
-            self.run_context.context.execution["submissions"][task_id].append({
-                "job_id": job_id,
-                "backend": task.submittable,
-                "block": block,
-            })
-
-            # Monitor job if blocking is enabled
-            if block:
-                self._monitor_job(task_id, job_id, submitor)
-
-            # Send job_id back to generator
-            result = generator.send(job_id)
-            if result is None:
-                job_spec = generator.send(job_id)
-            else:
-                return result
-
-    def _get_execution_spec(self, job_spec: Any) -> Any:
-        """Extract execution spec from JobSpec."""
-        if isinstance(job_spec, dict):
-            return job_spec.get("execution", {})
-        else:
-            return getattr(job_spec, "execution", None)
-
-    def _monitor_job(
-        self,
-        task_id: str,
-        job_id: int,
-        submitor: "SubmitorProtocol",
-        interval: int = 2,
-    ) -> None:
-        """Monitor a submitted job until completion.
-
-        Args:
-            task_id: Task identifier
-            job_id: Job ID to monitor
-            submitor: Submitor to query status from
-            interval: Polling interval in seconds
-        """
-        import time
-
-        logger.info(f"Monitoring job {job_id} for task {task_id}")
-        last_status = None
-
-        while True:
-            # Query job status
-            statuses = submitor.query(job_id)
-            job_status = statuses.get(job_id)
-
-            if job_status is None:
-                logger.warning(f"Job {job_id} not found in query results")
-                break
-
-            # Display status if changed
-            current_status = job_status.status.name
-            if current_status != last_status:
-                self._display_job_status(task_id, job_id, job_status)
-                last_status = current_status
-
-            # Check if finished
-            if job_status.is_finish:
-                if job_status.status.name == "FAILED":
-                    logger.error(f"Job {job_id} for task {task_id} failed")
-                    raise RuntimeError(f"Job {job_id} failed")
-                else:
-                    logger.info(f"Job {job_id} for task {task_id} completed successfully")
-                break
-
-            time.sleep(interval)
-
-    def _display_job_status(
-        self,
-        task_id: str,
-        job_id: int,
-        job_status: Any,
-    ) -> None:
-        """Display job status using molexp's logging system.
-
-        Args:
-            task_id: Task identifier
-            job_id: Job ID
-            job_status: JobStatus object from molq
-        """
-        status_name = job_status.status.name
-        job_name = getattr(job_status, "name", "")
-
-        # Color-coded status display
-        status_colors = {
-            "PENDING": "yellow",
-            "RUNNING": "blue",
-            "COMPLETED": "green",
-            "FAILED": "red",
-            "FINISHED": "green",
-        }
-        color = status_colors.get(status_name, "white")
-
-        # Log with appropriate level
-        if status_name == "FAILED":
-            logger.error(f"Task {task_id} | Job {job_id} [{job_name}]: {status_name}")
-        elif status_name in ("COMPLETED", "FINISHED"):
-            logger.info(f"Task {task_id} | Job {job_id} [{job_name}]: {status_name}")
-        else:
-            logger.info(f"Task {task_id} | Job {job_id} [{job_name}]: {status_name}")
-
-        # Also display to console using rich
-        console.print(
-            f"[bold]{task_id}[/bold] | Job {job_id} [{job_name}]: [{color}]{status_name}[/{color}]"
-        )
-
-    def _resolve_inputs(
-        self,
-        task_id: str,
-        global_kwargs: dict[str, Any],
-        context: "Context",
-    ) -> dict[str, Any]:
-        """Resolve inputs for a task using explicit link mappings."""
-        task_inputs: dict[str, Any] = {}
-        
-        # Get target task to check its input requirements
-        target_task = self._task_map.get(task_id)
-        if not target_task or not target_task.inputs:
-            return task_inputs
-        
-        # 1. Pick from global kwargs based on task input names
-        for input_name in target_task.inputs.keys():
-            if input_name in global_kwargs:
-                task_inputs[input_name] = global_kwargs[input_name]
-        
-        # 2. Collect outputs from upstream tasks via links
-        for link in self.workflow.links:
-            if link.target == task_id:
-                source_task_id = link.source
-                # Get outputs from source task results
-                if source_task_id in context.results:
-                    source_outputs = context.results[source_task_id]
-                    # Mapping is guaranteed to exist (auto-generated by compiler if None)
-                    if link.mapping:
-                        for output_name, input_name in link.mapping.items():
-                            if output_name not in source_outputs:
-                                raise ValueError(
-                                    f"Link mapping references missing output '{output_name}' "
-                                    f"from task '{source_task_id}'"
-                                )
-                            task_inputs[input_name] = source_outputs[output_name]
-        
-        return task_inputs
-
-    def _validate_inputs(self, task_id: str, task_inputs: dict[str, Any]) -> None:
-        """Fail fast if required inputs are missing."""
-        target_task = self._task_map.get(task_id)
-        if not target_task or not target_task.inputs:
-            return
-        missing = [
-            input_name
-            for input_name in target_task.inputs.keys()
-            if input_name not in task_inputs
-        ]
-        if missing:
-            missing_list = ", ".join(missing)
-            raise ValueError(
-                f"Task '{task_id}' missing required inputs: {missing_list}"
-            )
-
-    def _handle_task_failure(
-        self,
-        task_id: str,
-        error: Exception,
-        tasks_to_execute: set[str] | None = None,
-        in_degree: dict[str, int] | None = None,
-        context: "Context | None" = None,
-    ) -> None:
-        """Handle task failure and propagate to dependents."""
-        if context is None:
-            context = self.run_context.context
-        
-        mark_failed(context, task_id, error)
-        
-        # Print beautiful error message with full traceback
-        print_task_error(task_id, context.errors[task_id])
-        
-        # Propagate failure to all dependents (only in subgraph if provided)
-        self._propagate_failure(task_id, tasks_to_execute, context)
-
-    def _propagate_failure(
-        self,
-        failed_task_id: str,
-        tasks_to_execute: set[str] | None = None,
-        context: "Context | None" = None,
-    ) -> None:
-        """Propagate failure to all dependent tasks."""
-        if context is None:
-            context = self.run_context.context
-        
-        queue = [failed_task_id]
-        visited = set()
-        
-        while queue:
-            task_id = queue.pop(0)
-            if task_id in visited:
-                continue
-            visited.add(task_id)
-            
-            # Cancel all dependents (only in subgraph if provided)
-            for dependent_id in self._adj.get(task_id, []):
-                if tasks_to_execute is None or dependent_id in tasks_to_execute:
-                    if not is_failed_or_cancelled(context, dependent_id):
-                        mark_cancelled(context, dependent_id)
-                        logger.warning(f"⚠️  Task {dependent_id} cancelled due to upstream failure")
-                        queue.append(dependent_id)
-
-    def _execute_hybrid(self, **kwargs: Any) -> dict[str, dict[str, Any]]:
-        """Execute workflow with Actor support using asyncio event loop.
-
-        Handles both batch tasks (wrapped with asyncio.to_thread) and Actor tasks
-        (native coroutines) in a unified asyncio event loop.
-
-        Args:
-            **kwargs: Flat keyword arguments for task dependency injection
-
-        Returns:
-            Dict mapping task IDs to their output dicts
-        """
-        context = self.run_context.context
-
-        # Set context status to RUNNING
-        context.status["run"] = RunStatus.RUNNING
-
-        # Get task types and channels from compiler
-        task_types = self.compiled.get_task_types()
-        channel_configs = self.compiled.get_channels()
-
-        # Create asyncio.Queue instances for channels
-        channels = {}
-        for channel_id, config in channel_configs.items():
-            buffer_size = config['buffer_size']
-            channels[channel_id] = asyncio.Queue(maxsize=buffer_size)
-            logger.debug(f"Created channel {channel_id} with buffer_size={buffer_size}")
-
-        # Note: Channels are registered by _run_actor with logical names (e.g., 'data', 'results')
-        # not with physical IDs (e.g., 'ActorA_to_ActorB')
-
-        # Run asyncio event loop
-        results = asyncio.run(self._run_hybrid_workflow(task_types, channels, channel_configs, kwargs))
-        return results
-
-    async def _run_hybrid_workflow(
-        self,
-        task_types: dict[str, TaskExecutionType],
-        channels: dict[str, asyncio.Queue],
-        channel_configs: dict[str, Any],
-        kwargs: dict[str, Any]
-    ) -> dict[str, dict[str, Any]]:
-        """Run hybrid workflow in asyncio event loop.
-
-        Args:
-            task_types: Dict of task_id -> TaskExecutionType
-            channels: Dict of channel_id -> asyncio.Queue
-            channel_configs: Dict of channel configurations
-            kwargs: Global kwargs for tasks
-
-        Returns:
-            Dict of task results
-        """
-        context = self.run_context.context
-
-        # Compute subgraph
-        tasks_to_execute, _ = self._compute_subgraph(self._phases)
-
-        # Create tasks (actors as coroutines, batch as wrapped threads)
-        coroutines = []
-        for task_id in tasks_to_execute:
-            task = self._task_map[task_id]
-            task_type = task_types.get(task_id, TaskExecutionType.BATCH)
-
-            if task_type == TaskExecutionType.ACTOR:
-                # Actor - create coroutine
-                coro = self._run_actor(task_id, task, channels, channel_configs)
-                coroutines.append(coro)
-            else:
-                # Batch task - wrap in asyncio.to_thread
-                # For simplicity in Phase 1, we'll just run actors
-                # Batch tasks would need more complex orchestration
-                logger.warning(f"Batch task {task_id} in hybrid mode - will skip for Phase 1")
-
-        # Run all actors concurrently
-        logger.debug(f"Starting {len(coroutines)} actors")
-        await asyncio.gather(*coroutines, return_exceptions=True)
-
-        return context.results
-
-    async def _run_actor(
-        self,
-        task_id: str,
-        task: Actor,
-        channels: dict[str, asyncio.Queue],
-        channel_configs: dict[str, Any]
-    ) -> None:
-        """Run a single actor.
-
-        Args:
-            task_id: Task identifier
-            task: Actor instance
-            channels: All channels
-            channel_configs: Channel configurations
-        """
-        context = self.run_context.context
-        context.tasks[task_id] = TaskStatus.RUNNING
-        logger.debug(f"Starting actor {task_id}")
-
-        # Setup channel routing for this actor
-        # Find channels where this actor is source or target
-        actor_channels = {}
-        for channel_id, config in channel_configs.items():
-            if config['source'] == task_id:
-                # This actor is the source
-                actor_channels[channel_id] = channels[channel_id]
-            elif config['target'] == task_id:
-                # This actor is the target
-                actor_channels[channel_id] = channels[channel_id]
-
-        # Register channels for this actor using Link mapping names
-        for channel_id, queue in actor_channels.items():
-            config = channel_configs[channel_id]
-            mapping = config.get('mapping', {})
-
-            if config['source'] == task_id:
-                # Actor is source - register output names from mapping keys
-                for output_name in mapping.keys():
-                    self.run_context._register_channel(output_name, queue)
-                    logger.debug(f"Registered channel '{output_name}' (emit) for actor {task_id}")
-
-            elif config['target'] == task_id:
-                # Actor is target - register input names from mapping values
-                for input_name in mapping.values():
-                    self.run_context._register_channel(input_name, queue)
-                    logger.debug(f"Registered channel '{input_name}' (receive) for actor {task_id}")
-
-        # Execute actor with isolation - catch exceptions to allow other actors to continue
-        try:
-            gen = task.execute(ctx=self.run_context)
-
-            # Run actor generator
-            async for output in gen:
-                # Actor yielded - could handle control signals here
-                pass
-
-            # Get actor's final result (if it called ctx.set_result)
-            result = context.results.get(task_id, {})
-            mark_succeeded(context, task_id, result)
-            logger.debug(f"Actor {task_id} completed")
-        except Exception as e:
-            # Actor failed - mark failure but allow other actors to continue
-            mark_failed(context, task_id, e)
-            logger.error(f"Actor {task_id} failed: {e}")
-            print_task_error(task_id, context.errors[task_id])
diff --git a/src/molexp/workflow/execution_type.py b/src/molexp/workflow/execution_type.py
deleted file mode 100644
index a1511a70..00000000
--- a/src/molexp/workflow/execution_type.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""Task execution type classification for hybrid workflow execution.
-
-This module defines the TaskExecutionType enum used by WorkflowCompiler to classify
-tasks and select appropriate execution strategies:
-
-- **BATCH**: Traditional tasks that execute once and return results directly.
-  Execute in dependency order using ThreadPoolExecutor.
-
-- **ACTOR**: Continuous tasks that return AsyncGenerator and run indefinitely.
-  Execute concurrently in asyncio event loop with message passing support.
-
-The compiler detects execution types automatically by inspecting execute() method
-return annotations:
-    - `-> dict` → BATCH
-    - `-> AsyncGenerator[None, dict]` → ACTOR
-
-Example:
-    Defining task types::
-
-        # BATCH task
-        class DataLoader(Task[LoadConfig, dict]):
-            def execute(self, ctx, **inputs) -> dict:
-                return {"data": load_data()}
-
-        # ACTOR task
-        class StreamProcessor(Actor[ProcessConfig, dict]):
-            async def execute(self, ctx, **inputs) -> AsyncGenerator[None, dict]:
-                while True:
-                    item = await ctx.receive('input')
-                    yield
-"""
-
-from enum import Enum
-
-
-class TaskExecutionType(Enum):
-    """Classification of task execution modes.
-
-    BATCH: Traditional task that executes once and returns a dict
-    ACTOR: Continuous actor that returns AsyncGenerator and runs indefinitely
-    """
-
-    BATCH = "batch"
-    ACTOR = "actor"
diff --git a/src/molexp/workflow/link.py b/src/molexp/workflow/link.py
deleted file mode 100644
index a5b3f515..00000000
--- a/src/molexp/workflow/link.py
+++ /dev/null
@@ -1,103 +0,0 @@
-"""Link abstraction for workflow connections and channel configuration.
-
-This module provides the Link class for defining dependencies and message channels
-between tasks in a workflow graph. Links serve dual purposes:
-
-1. **Dependency Specification**: Define execution order for batch workflows
-2. **Channel Configuration**: Configure message passing buffers for actor workflows
-
-For batch tasks, Links specify data flow via output-to-input mappings.
-For actor tasks, Links define asyncio.Queue channels with configurable buffer sizes
-and explicit channel name routing.
-
-Example:
-    Basic dependency link::
-
-        link = Link(source='task_a', target='task_b')
-
-    Actor channel with buffer::
-
-        link = Link(
-            source='generator_actor',
-            target='processor_actor',
-            buffer_size=200,
-            mapping={'data': 'input_data'}
-        )
-
-    Creating workflow with links::
-
-        workflow = Workflow.from_tasks(
-            tasks=[actorA, actorB, actorC],
-            links=[
-                Link(source=actorA, target=actorB, mapping={'out': 'in'}),
-                Link(source=actorB, target=actorC, buffer_size=50)
-            ]
-        )
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from pydantic import BaseModel, field_validator
-
-if TYPE_CHECKING:
-    from .task import Task
-
-
-class Link(BaseModel):
-    """Connection between two tasks in a workflow.
-
-    Links represent dependencies between tasks with explicit or automatic
-    output-to-input mappings. For Actor workflows, Links also define message
-    channels with configurable buffering.
-
-    Attributes:
-        source: Source task (Task instance or task ID string)
-        target: Target task (Task instance or task ID string)
-        mapping: Optional output-to-input mapping. If None, auto-maps matching names.
-        buffer_size: Buffer size for actor channels (default: 100).
-                    Used when link involves Actors. Larger buffers reduce backpressure
-                    but use more memory.
-        channels: Optional channel name mapping for actors. Maps source channel names
-                 to target channel names. If None, assumes matching names.
-                 Example: {'out': 'in'} means source.emit('out') -> target.receive('in')
-        status: Link status (default "pending")
-
-    Examples:
-        Basic link:
-            >>> Link('task_a', 'task_b')
-
-        With buffer size:
-            >>> Link('actor_a', 'actor_b', buffer_size=200)
-
-        With channel mapping:
-            >>> Link('generator', 'processor', channels={'data': 'input_data'})
-    """
-
-    source: str
-    target: str
-    mapping: dict[str, str] | None = None
-    buffer_size: int = 100
-    channels: dict[str, str] | None = None
-    status: str = "pending"
-
-    model_config = {"arbitrary_types_allowed": True}
-
-    @field_validator("source", "target", mode="before")
-    @classmethod
-    def extract_task_id(cls, v: Any) -> str:
-        """Extract task_id from Task instance or return string as-is.
-
-        Args:
-            v: Task instance or string task ID
-
-        Returns:
-            Task ID as string
-        """
-        # Import here to avoid circular imports
-        from .task import Task
-
-        if isinstance(v, Task):
-            return v.task_id
-        return v
diff --git a/src/molexp/workflow/nodes/__init__.py b/src/molexp/workflow/nodes/__init__.py
deleted file mode 100644
index 4b1d11f3..00000000
--- a/src/molexp/workflow/nodes/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Builtin workflow nodes."""
diff --git a/src/molexp/workflow/nodes/__pycache__/__init__.cpython-312.pyc b/src/molexp/workflow/nodes/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index 49d0039e..00000000
Binary files a/src/molexp/workflow/nodes/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/nodes/__pycache__/register.cpython-312.pyc b/src/molexp/workflow/nodes/__pycache__/register.cpython-312.pyc
deleted file mode 100644
index 2d3ed3d0..00000000
Binary files a/src/molexp/workflow/nodes/__pycache__/register.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/nodes/register.py b/src/molexp/workflow/nodes/register.py
deleted file mode 100644
index c2e9de63..00000000
--- a/src/molexp/workflow/nodes/register.py
+++ /dev/null
@@ -1,15 +0,0 @@
-"""Builtin nodes registration entry point."""
-
-from molexp.workflow.plugin.registry import TaskRegistry
-
-# Import control tasks to trigger registration
-from molexp.workflow.control import conditional, loop, map, reduce
-
-def register_builtin_nodes(registry: TaskRegistry) -> None:
-    """Register builtin nodes.
-    
-    This function is called by the plugin loader.
-    Simply importing the control modules above is sufficient to register
-    default tasks via their @register decorators to the global registry.
-    """
-    pass
diff --git a/src/molexp/workflow/plugin/__init__.py b/src/molexp/workflow/plugin/__init__.py
deleted file mode 100644
index b736e97b..00000000
--- a/src/molexp/workflow/plugin/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-"""Plugin system for molexp tasks.
-
-This package provides the infrastructure for discovering and loading
-task plugins via Python entry points.
-"""
-
-from .loader import load_plugins
-from .metadata import TaskMetadata, PortMetadata
-from .registry import TaskRegistry, get_task_registry
-
-__all__ = [
-    "TaskMetadata",
-    "PortMetadata",
-    "TaskRegistry",
-    "get_task_registry",
-    "load_plugins",
-]
diff --git a/src/molexp/workflow/plugin/__pycache__/__init__.cpython-312.pyc b/src/molexp/workflow/plugin/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index 527581b8..00000000
Binary files a/src/molexp/workflow/plugin/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/plugin/__pycache__/loader.cpython-312.pyc b/src/molexp/workflow/plugin/__pycache__/loader.cpython-312.pyc
deleted file mode 100644
index 0e235a97..00000000
Binary files a/src/molexp/workflow/plugin/__pycache__/loader.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/plugin/__pycache__/metadata.cpython-312.pyc b/src/molexp/workflow/plugin/__pycache__/metadata.cpython-312.pyc
deleted file mode 100644
index 855aa0f0..00000000
Binary files a/src/molexp/workflow/plugin/__pycache__/metadata.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workflow/plugin/loader.py b/src/molexp/workflow/plugin/loader.py
deleted file mode 100644
index 01622830..00000000
--- a/src/molexp/workflow/plugin/loader.py
+++ /dev/null
@@ -1,84 +0,0 @@
-"""Entry point discovery and plugin loading."""
-
-from __future__ import annotations
-
-from importlib.metadata import entry_points
-from typing import Callable
-
-from molexp.config import get_config
-from mollog import get_logger
-from .registry import TaskRegistry, get_task_registry
-
-logger = get_logger(__name__)
-
-# Entry point group name
-ENTRY_POINT_GROUP = "molexp.nodes"
-
-
-def load_plugins(
-    registry: TaskRegistry | None = None,
-    fail_fast: bool | None = None,
-) -> None:
-    """Discover and load all task plugins via entry points.
-
-    This function:
-    1. Discovers all entry points in the "molexp.nodes" group
-    2. Loads each registration function
-    3. Calls it with the task registry
-    4. Handles errors gracefully (logs and continues)
-
-    Args:
-        registry: Task registry to use (defaults to global registry)
-    """
-    if registry is None:
-        registry = get_task_registry()
-
-    # Check if already loaded
-    if registry.is_loaded():
-        logger.debug("Plugins already loaded, skipping")
-        return
-
-    logger.info(f"Loading plugins from entry point group: {ENTRY_POINT_GROUP}")
-
-    # Discover entry points
-    try:
-        eps = entry_points(group=ENTRY_POINT_GROUP)
-    except TypeError:
-        # Python 3.9 compatibility
-        eps = entry_points().get(ENTRY_POINT_GROUP, [])
-
-    loaded_count = 0
-    error_count = 0
-
-    if fail_fast is None:
-        fail_fast = get_config().plugin_fail_fast
-
-    for ep in sorted(eps, key=lambda item: item.name):
-        try:
-            logger.debug(f"Loading plugin: {ep.name} from {ep.value}")
-
-            # Load the registration function
-            register_func: Callable[[TaskRegistry], None] = ep.load()
-
-            # Call it with the registry
-            register_func(registry)
-
-            loaded_count += 1
-            logger.info(f"Successfully loaded plugin: {ep.name}")
-
-        except Exception as e:
-            error_count += 1
-            logger.error(
-                f"Failed to load plugin '{ep.name}' from '{ep.value}': {e}",
-                exc_info=True,
-            )
-            if fail_fast:
-                raise RuntimeError(
-                    f"Plugin load failed for '{ep.name}' from '{ep.value}'"
-                ) from e
-            continue
-
-    # Mark registry as loaded
-    registry.mark_loaded()
-
-    logger.info(f"Plugin loading complete: {loaded_count} loaded, {error_count} failed")
diff --git a/src/molexp/workflow/plugin/metadata.py b/src/molexp/workflow/plugin/metadata.py
deleted file mode 100644
index 8d386aec..00000000
--- a/src/molexp/workflow/plugin/metadata.py
+++ /dev/null
@@ -1,55 +0,0 @@
-"""Metadata models for task plugins."""
-
-from __future__ import annotations
-
-from typing import Any, List, Optional
-
-from pydantic import BaseModel, Field
-
-
-class PortMetadata(BaseModel):
-    """Metadata for a task input or output port.
-
-    Attributes:
-        name: Port identifier
-        type: Type descriptor ("string", "number", "boolean", "object", "array", "any")
-        description: Human-readable description
-        required: Whether this port is required
-    """
-
-    name: str = Field(..., description="Port identifier")
-    type: str = Field(..., description="Type descriptor")
-    description: str = Field(default="", description="Port description")
-    required: bool = Field(default=True, description="Whether port is required")
-
-
-class TaskMetadata(BaseModel):
-    """Metadata for a task type.
-
-    Attributes:
-        label: Human-readable name
-        category: Task category (e.g., "io", "text", "http")
-        description: Detailed description
-        inputs: Input port definitions
-        outputs: Output port definitions
-        icon: Optional icon name
-        tags: Optional tags for search/filtering
-    """
-
-    label: str = Field(..., description="Human-readable name")
-    category: str = Field(..., description="Task category")
-    description: str = Field(..., description="Detailed description")
-    inputs: List[PortMetadata] = Field(default_factory=list, description="Input ports")
-    outputs: List[PortMetadata] = Field(
-        default_factory=list, description="Output ports"
-    )
-    icon: Optional[str] = Field(default=None, description="Icon name")
-    tags: List[str] = Field(default_factory=list, description="Search tags")
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for JSON serialization.
-
-        Returns:
-            Dictionary representation
-        """
-        return self.model_dump(mode="json")
diff --git a/src/molexp/workflow/plugin/registry.py b/src/molexp/workflow/plugin/registry.py
deleted file mode 100644
index 62e72782..00000000
--- a/src/molexp/workflow/plugin/registry.py
+++ /dev/null
@@ -1,333 +0,0 @@
-"""Task registry for managing registered task types.
-
-This is the single source of truth for task registration. It combines:
-- Plugin metadata (label, category, ports) for API/UI
-- Execution mapping (task_type_id <-> task_class) for workflow serialization
-"""
-
-from __future__ import annotations
-
-from typing import Any, Callable, Dict, List, Optional, Type
-
-from pydantic import BaseModel
-
-from ..task import Task
-from mollog import get_logger
-from .metadata import TaskMetadata
-
-logger = get_logger(__name__)
-
-
-class TaskRegistration:
-    """Registration entry for a task type.
-
-    Attributes:
-        task_type_id: Unique task identifier
-        task_class: Task class
-        config_class: Configuration model class
-        metadata: Task metadata
-    """
-
-    def __init__(
-        self,
-        task_type_id: str,
-        task_class: Type[Task],
-        config_class: Type[BaseModel],
-        metadata: TaskMetadata,
-    ):
-        self.task_type_id = task_type_id
-        self.task_class = task_class
-        self.config_class = config_class
-        self.metadata = metadata
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for API responses.
-
-        Returns:
-            Dictionary with task metadata and config schema
-        """
-        return {
-            "id": self.task_type_id,
-            "label": self.metadata.label,
-            "category": self.metadata.category,
-            "description": self.metadata.description,
-            "inputs": [port.model_dump(mode="json") for port in self.metadata.inputs],
-            "outputs": [port.model_dump(mode="json") for port in self.metadata.outputs],
-            "icon": self.metadata.icon,
-            "tags": self.metadata.tags,
-            "config_schema": self.config_class.model_json_schema(),
-        }
-
-
-class TaskRegistry:
-    """Central registry for all task types.
-
-    This registry is populated via entry points or direct registration and
-    provides both metadata for API/UI and class lookup for workflow execution.
-    """
-
-    def __init__(self):
-        self._tasks: Dict[str, TaskRegistration] = {}
-        self._class_to_id: Dict[Type[Task], str] = {}
-        self._loaded = False
-
-    @staticmethod
-    def derive_task_id(task_class: Type[Task]) -> str:
-        """Derive a deterministic task type ID from a class."""
-        return f"{task_class.__module__}.{task_class.__qualname__}"
-
-    # ========== Registration ==========
-
-    def register(
-        self,
-        task_type_id: str,
-        task_class: Type[Task],
-        metadata: TaskMetadata,
-        config_class: Optional[Type[BaseModel]] = None,
-    ) -> str:
-        """Register a task type.
-
-        Args:
-            task_type_id: Unique task identifier (e.g., "io.read_file")
-            task_class: Task class
-            metadata: Task metadata
-            config_class: Configuration class (defaults to task_class.config_type)
-
-        Returns:
-            The registered task type ID.
-
-        Raises:
-            ValueError: If task_type_id collides or task_class lacks config_type
-        """
-        if task_type_id in self._tasks:
-            existing = self._tasks[task_type_id]
-            if existing.task_class is not task_class:
-                raise ValueError(
-                    f"Task type ID '{task_type_id}' already registered to "
-                    f"{existing.task_class.__name__}, cannot register {task_class.__name__}"
-                )
-            return task_type_id  # Already registered, idempotent
-
-        # Check for class already registered under different ID
-        prior_id = self._class_to_id.get(task_class)
-        if prior_id is not None and prior_id != task_type_id:
-            raise ValueError(
-                f"{task_class.__name__} already registered as '{prior_id}', "
-                f"cannot register as '{task_type_id}'"
-            )
-
-        # Resolve config class
-        if config_class is None:
-            if not hasattr(task_class, "config_type"):
-                raise ValueError(
-                    f"Task class {task_class.__name__} must have 'config_type' attribute "
-                    f"or config_class must be provided"
-                )
-            config_class = task_class.config_type
-
-        registration = TaskRegistration(
-            task_type_id=task_type_id,
-            task_class=task_class,
-            config_class=config_class,
-            metadata=metadata,
-        )
-
-        self._tasks[task_type_id] = registration
-        self._class_to_id[task_class] = task_type_id
-        setattr(task_class, "task_type_id", task_type_id)
-
-        logger.info(f"Registered task: {task_type_id} ({task_class.__name__})")
-        return task_type_id
-
-    def register_task(
-        self,
-        task_class: Type[Task],
-        task_type_id: str | None = None,
-    ) -> str:
-        """Register a task class without rich metadata.
-
-        This is the simpler registration path for programmatic use (no plugin
-        metadata). A minimal TaskMetadata is auto-generated.
-
-        Args:
-            task_class: Task class to register
-            task_type_id: Explicit type ID (optional). If omitted, derived from module path.
-
-        Returns:
-            The registered task type ID.
-        """
-        if task_type_id is None:
-            task_type_id = self.derive_task_id(task_class)
-
-        # Check if already registered
-        if task_class in self._class_to_id:
-            return self._class_to_id[task_class]
-
-        # Auto-generate minimal metadata
-        label = task_class.__name__.replace("Task", "")
-        parts = task_type_id.split(".")
-        category = parts[0] if len(parts) > 1 else "general"
-
-        metadata = TaskMetadata(
-            label=label,
-            category=category,
-            description=task_class.__doc__ or f"{label} task",
-            inputs=[],
-            outputs=[],
-        )
-
-        return self.register(
-            task_type_id=task_type_id,
-            task_class=task_class,
-            metadata=metadata,
-        )
-
-    # ========== Lookup ==========
-
-    def has(self, task_type_id: str) -> bool:
-        """Check if a task type ID is registered."""
-        return task_type_id in self._tasks
-
-    def get(self, task_type_id: str) -> Optional[TaskRegistration]:
-        """Get registration for a task type ID.
-
-        Args:
-            task_type_id: Task identifier
-
-        Returns:
-            Registration entry or None if not found
-        """
-        return self._tasks.get(task_type_id)
-
-    def get_task_class(self, task_type_id: str) -> Type[Task]:
-        """Get task class by type ID.
-
-        Args:
-            task_type_id: Task identifier
-
-        Returns:
-            Task class
-
-        Raises:
-            ValueError: If task type not registered
-        """
-        reg = self._tasks.get(task_type_id)
-        if reg is None:
-            raise ValueError(
-                f"Task type '{task_type_id}' not registered. "
-                f"Available: {sorted(self._tasks.keys())}"
-            )
-        return reg.task_class
-
-    def get_task_id(self, task_class: Type[Task]) -> str:
-        """Get the registered task type ID for a class.
-
-        Args:
-            task_class: Task class
-
-        Returns:
-            Registered task type ID
-
-        Raises:
-            ValueError: If class not registered
-        """
-        if task_class not in self._class_to_id:
-            raise ValueError(
-                f"{task_class.__name__} is not registered. "
-                "Register with register_task() before serialization."
-            )
-        return self._class_to_id[task_class]
-
-    # ========== Listing ==========
-
-    def list_all(self) -> List[TaskRegistration]:
-        """List all registered tasks."""
-        return list(self._tasks.values())
-
-    def list_ids(self) -> list[str]:
-        """List all registered task type IDs."""
-        return sorted(self._tasks.keys())
-
-    def list_by_category(self, category: str) -> List[TaskRegistration]:
-        """List tasks in a specific category."""
-        return [
-            reg for reg in self._tasks.values() if reg.metadata.category == category
-        ]
-
-    # ========== Export ==========
-
-    def to_dict(self) -> dict[str, Any]:
-        """Export all tasks as dictionary for API."""
-        return {"nodes": [reg.to_dict() for reg in self._tasks.values()]}
-
-    # ========== Lifecycle ==========
-
-    def mark_loaded(self) -> None:
-        """Mark registry as loaded (plugins have been discovered)."""
-        self._loaded = True
-
-    def is_loaded(self) -> bool:
-        """Check if plugins have been loaded."""
-        return self._loaded
-
-
-# Global registry instance
-_global_registry: Optional[TaskRegistry] = None
-
-
-def get_task_registry() -> TaskRegistry:
-    """Get the global task registry instance.
-
-    Returns:
-        Global TaskRegistry
-    """
-    global _global_registry
-    if _global_registry is None:
-        _global_registry = TaskRegistry()
-    return _global_registry
-
-
-def register(task_type_id: str | None = None, metadata: Optional[TaskMetadata] = None) -> Callable:
-    """Decorator to register a task class.
-
-    If metadata is not provided, minimal metadata will be auto-generated.
-    If task_type_id is omitted, a deterministic ID is derived from module path.
-
-    Args:
-        task_type_id: Unique task identifier
-        metadata: Optional task metadata
-
-    Returns:
-        Decorator function
-    """
-
-    def decorator(task_class: Type[Task]) -> Type[Task]:
-        resolved_id = task_type_id or TaskRegistry.derive_task_id(task_class)
-
-        # Auto-generate minimal metadata if not provided
-        if metadata is None:
-            parts = resolved_id.split(".")
-            category = parts[0] if len(parts) > 1 else "general"
-            label = task_class.__name__.replace("Task", "")
-
-            auto_metadata = TaskMetadata(
-                label=label,
-                category=category,
-                description=task_class.__doc__ or f"{label} task",
-                inputs=[],
-                outputs=[],
-            )
-            final_metadata = auto_metadata
-        else:
-            final_metadata = metadata
-
-        registry = get_task_registry()
-        registry.register(
-            task_type_id=resolved_id,
-            task_class=task_class,
-            metadata=final_metadata,
-        )
-
-        return task_class
-
-    return decorator
diff --git a/src/molexp/workflow/protocol.py b/src/molexp/workflow/protocol.py
deleted file mode 100644
index d1148637..00000000
--- a/src/molexp/workflow/protocol.py
+++ /dev/null
@@ -1,58 +0,0 @@
-"""Protocol definitions for workflow tasks.
-
-This module defines the structural interface that all workflow tasks must implement,
-using Python's typing.Protocol for duck typing without inheritance.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Protocol, runtime_checkable
-
-__all__ = ["TaskProtocol"]
-
-
-@runtime_checkable
-class TaskProtocol(Protocol):
-    """Structural interface for workflow tasks.
-    
-    Any class implementing these methods is protocol-compatible for in-process use.
-    Persisted workflows still require Task classes with Pydantic configurations.
-    
-    Example:
-        >>> from pydantic import BaseModel
-        >>> class MyConfig(BaseModel):
-        ...     value: int
-    """
-    
-    def execute(self, ctx: Any | None = None, **inputs: Any) -> dict[str, Any]:
-        """Execute the task with given inputs.
-        
-        Args:
-            ctx: Optional runtime context (e.g., RunContext) for accessing
-                 directories, logging, asset registration, etc.
-            **inputs: Named input values matching the task's input schema
-            
-        Returns:
-            Dictionary of named outputs matching the task's output schema
-            
-        Example:
-            >>> task.execute(input=data, ctx=run_context)
-            {'result': <computed_value>}
-        """
-        ...
-    
-    def dump(self) -> dict[str, Any]:
-        """Serialize task configuration to dictionary.
-        
-        This method enables task persistence, reproducibility, and inspection.
-        The returned dictionary should contain all configuration parameters
-        needed to reconstruct the task.
-        
-        Returns:
-            Dictionary representation of task configuration
-            
-        Example:
-            >>> task.dump()
-            {'param1': 'value1', 'param2': 42}
-        """
-        ...
diff --git a/src/molexp/workflow/protocols.py b/src/molexp/workflow/protocols.py
new file mode 100644
index 00000000..01cb16d3
--- /dev/null
+++ b/src/molexp/workflow/protocols.py
@@ -0,0 +1,66 @@
+"""Structural protocols for workflow nodes.
+
+Any object matching these protocols can participate in a molexp workflow
+**without importing molexp**. This enables zero-dependency integration
+with third-party libraries.
+
+Three ways to define a task — all equivalent at runtime:
+
+1. Function decorated with ``@wf.task``::
+
+       @wf.task
+       async def fetch(ctx): ...
+
+2. Subclass ``Task`` (convenience base, optional)::
+
+       class Fetch(Task):
+           async def execute(self, ctx: TaskContext) -> dict: ...
+
+3. Any object with a matching method (third-party, zero import)::
+
+       # In another package — no molexp dependency needed
+       class ExternalFetch:
+           async def execute(self, ctx) -> dict: ...
+"""
+
+from __future__ import annotations
+
+from typing import Any, AsyncIterator, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class Runnable(Protocol):
+    """Protocol for batch task nodes.
+
+    Any object with ``async execute(ctx) -> output`` qualifies.
+    The ``ctx`` argument will be a :class:`~molexp.workflow.context.TaskContext`
+    at runtime, but the protocol deliberately types it as ``Any`` so that
+    third-party implementations need not import molexp.
+
+    Example (no molexp import needed)::
+
+        class MyProcessor:
+            async def execute(self, ctx) -> dict:
+                data = ctx.inputs
+                return {"processed": data}
+    """
+
+    async def execute(self, ctx: Any) -> Any: ...
+
+
+@runtime_checkable
+class Streamable(Protocol):
+    """Protocol for streaming actor nodes.
+
+    Any object with ``async run(ctx) -> AsyncIterator`` qualifies.
+
+    Example::
+
+        class MyStreamer:
+            async def run(self, ctx):
+                while True:
+                    msg = await ctx.receive()
+                    yield transform(msg)
+    """
+
+    async def run(self, ctx: Any) -> AsyncIterator[Any]: ...
diff --git a/src/molexp/workflow/registry.py b/src/molexp/workflow/registry.py
deleted file mode 100644
index d58a9ccc..00000000
--- a/src/molexp/workflow/registry.py
+++ /dev/null
@@ -1,32 +0,0 @@
-"""Task registry convenience functions.
-
-This module re-exports registry functions from the unified plugin registry.
-All registration state lives in ``workflow.plugin.registry.TaskRegistry``.
-"""
-
-from __future__ import annotations
-
-from typing import Type
-
-from .task import Task
-from .plugin.registry import TaskRegistry, get_task_registry
-
-
-def register_task(task_class: Type[Task], task_type_id: str | None = None) -> str:
-    """Register a task class in the global registry."""
-    return get_task_registry().register_task(task_class, task_type_id=task_type_id)
-
-
-def get_task_class(task_type_id: str) -> Type[Task]:
-    """Get a task class by exact type ID."""
-    return get_task_registry().get_task_class(task_type_id)
-
-
-def get_task_id(task_class: Type[Task]) -> str:
-    """Get the registered task type ID for a class."""
-    return get_task_registry().get_task_id(task_class)
-
-
-def list_registered_tasks() -> list[str]:
-    """List all registered task type IDs."""
-    return get_task_registry().list_ids()
diff --git a/src/molexp/workflow/runtime.py b/src/molexp/workflow/runtime.py
new file mode 100644
index 00000000..1cb8983f
--- /dev/null
+++ b/src/molexp/workflow/runtime.py
@@ -0,0 +1,53 @@
+"""Abstract workflow runtime and default factory.
+
+The runtime is the execution backend for :class:`WorkflowSpec`.
+``GraphWorkflowRuntime`` (backed by pydantic-graph) is the only concrete
+implementation.  Users never import the runtime directly —
+``WorkflowSpec`` creates one lazily on first ``execute()`` / ``start()``.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from molexp.config import ProfileConfig
+
+from .types import WorkflowExecution, WorkflowResult
+
+
+class WorkflowRuntime(ABC):
+    """Backend that knows how to execute a compiled workflow."""
+
+    @abstractmethod
+    async def execute(
+        self,
+        spec: Any,
+        run: Any = None,
+        run_context: Any = None,
+        *,
+        profile_config: ProfileConfig | None = None,
+        **kwargs: Any,
+    ) -> WorkflowResult:
+        """Run the workflow to completion."""
+        ...
+
+    @abstractmethod
+    async def start(
+        self,
+        spec: Any,
+        run: Any = None,
+        run_context: Any = None,
+        *,
+        profile_config: ProfileConfig | None = None,
+        **kwargs: Any,
+    ) -> WorkflowExecution:
+        """Launch the workflow in the background."""
+        ...
+
+
+def create_default_runtime() -> WorkflowRuntime:
+    """Return the default pydantic-graph runtime."""
+    from ._pydantic_graph.runtime import GraphWorkflowRuntime
+
+    return GraphWorkflowRuntime()
diff --git a/src/molexp/workflow/snapshot.py b/src/molexp/workflow/snapshot.py
new file mode 100644
index 00000000..47cc7d2e
--- /dev/null
+++ b/src/molexp/workflow/snapshot.py
@@ -0,0 +1,124 @@
+"""Task snapshot for immutable static identity.
+
+A TaskSnapshot captures the static identity of a Task — its code and configuration —
+as an immutable record. It does NOT know about inputs; that's the cache's job.
+
+Code hashing uses AST normalization to be insensitive to whitespace, comments,
+and formatting changes. Only semantic code changes produce a different hash.
+
+Usage:
+    snapshot = TaskSnapshot.create(task)
+    print(snapshot.key)  # deterministic identity string
+"""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+import inspect
+import json
+from mollog import get_logger
+import textwrap
+from datetime import datetime, timezone
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+logger = get_logger(__name__)
+
+
+def _normalize_ast(source: str) -> str:
+    """Normalize Python source via AST dump, stripping comments, whitespace and decorators.
+
+    Two functions that differ only in comments, blank lines, formatting, or
+    decorators (e.g. @jit, @cache) will produce the same normalized output.
+    Only the function body matters for semantic identity.
+    """
+    tree = ast.parse(textwrap.dedent(source))
+    # Strip decorator_list from all function/async-function definitions
+    # so that adding/removing decorators does not change the code hash.
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            node.decorator_list = []
+    return ast.dump(tree, annotate_fields=True, include_attributes=False)
+
+
+class TaskSnapshot(BaseModel):
+    """Immutable static snapshot of a Task.
+
+    Captures code_hash (AST-normalized execute() source) and config_hash
+    (serialized config). Together they form a deterministic identity key
+    for the task definition.
+    """
+
+    task_id: str
+    task_type: str
+    code_hash: str
+    config_hash: str
+    code_source: str = ""
+    created_at: datetime
+    config_data: dict[str, Any] = Field(default_factory=dict)
+
+    model_config = {"frozen": True}
+
+    @classmethod
+    def create(cls, task: Any) -> TaskSnapshot:
+        """Create a snapshot from a live Task instance."""
+        config_data = task.config.model_dump() if hasattr(task.config, "model_dump") else {}
+        return cls(
+            task_id=task.task_id,
+            task_type=f"{type(task).__module__}.{type(task).__qualname__}",
+            code_hash=cls._compute_code_hash(task),
+            config_hash=cls._compute_config_hash(task),
+            code_source=cls._get_code_source(task),
+            created_at=datetime.now(timezone.utc),
+            config_data=config_data,
+        )
+
+    @property
+    def key(self) -> str:
+        """Deterministic identity key = f(code_hash, config_hash)."""
+        return f"{self.code_hash}:{self.config_hash}"
+
+    @staticmethod
+    def _get_code_source(task: Any) -> str:
+        try:
+            return inspect.getsource(task.execute)
+        except (OSError, TypeError):
+            return ""
+
+    @staticmethod
+    def _compute_code_hash(task: Any) -> str:
+        """Hash execute() using AST normalization (whitespace/comment insensitive)."""
+        try:
+            source = inspect.getsource(task.execute)
+            normalized = _normalize_ast(source)
+            return hashlib.sha256(normalized.encode()).hexdigest()[:32]
+        except (OSError, TypeError):
+            pass
+        except SyntaxError:
+            pass
+
+        try:
+            code_obj = task.execute.__code__
+            bytecode_data = code_obj.co_code + repr(code_obj.co_consts).encode()
+            return hashlib.sha256(bytecode_data).hexdigest()[:32]
+        except AttributeError:
+            pass
+
+        logger.warning(
+            f"Cannot compute reliable code hash for task {task.task_id} "
+            f"({type(task).__qualname__}). Falling back to class identity."
+        )
+        identity = f"{type(task).__module__}.{type(task).__qualname__}"
+        return hashlib.sha256(identity.encode()).hexdigest()[:32]
+
+    @staticmethod
+    def _compute_config_hash(task: Any) -> str:
+        """Hash the task's serialized configuration."""
+        if hasattr(task.config, "model_dump"):
+            data = task.config.model_dump()
+        else:
+            data = {}
+        raw = json.dumps(data, sort_keys=True, default=str)
+        return hashlib.sha256(raw.encode()).hexdigest()[:32]
diff --git a/src/molexp/workflow/spec.py b/src/molexp/workflow/spec.py
new file mode 100644
index 00000000..9d5fd6fe
--- /dev/null
+++ b/src/molexp/workflow/spec.py
@@ -0,0 +1,369 @@
+"""Workflow specification: functional DSL and OOP builder.
+
+Two equivalent ways to define a workflow:
+
+Functional style::
+
+    wf = workflow(name="pipeline")
+
+    @wf.task
+    async def fetch(ctx: TaskContext) -> FetchResult: ...
+
+    @wf.task(depends_on=["fetch"])
+    async def validate(ctx: TaskContext) -> ValidateResult: ...
+
+    result = await wf.build().execute(run=run)
+
+OOP builder style::
+
+    wf = (
+        WorkflowBuilder(name="pipeline")
+        .add(FetchTask())
+        .add(ValidateTask(), depends_on=["fetch"])
+        .build()
+    )
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from collections.abc import Callable
+from typing import Any
+
+from molexp.config import ProfileConfig
+
+from .types import WorkflowExecution, WorkflowResult
+
+
+class TaskRegistration:
+    """Internal record of a registered task or actor."""
+
+    __slots__ = ("name", "fn_or_class", "depends_on", "is_actor", "remote")
+
+    def __init__(
+        self,
+        name: str,
+        fn_or_class: Any,
+        depends_on: list[str],
+        is_actor: bool = False,
+        remote: Any = None,
+    ) -> None:
+        self.name = name
+        self.fn_or_class = fn_or_class
+        self.depends_on = depends_on
+        self.is_actor = is_actor
+        self.remote = remote
+
+
+# ── WorkflowSpec ────────────────────────────────────────────────────────────
+
+
+class WorkflowSpec:
+    """Compiled, executable workflow specification.
+
+    Produced by ``WorkflowBuilder.build()`` or ``WorkflowDSL.build()``.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        workflow_id: str,
+        tasks: list[TaskRegistration],
+        mode: str = "batch",
+    ) -> None:
+        self.name = name
+        self.workflow_id = workflow_id
+        self._tasks = tasks
+        self._mode = mode
+        self._runtime: Any = None  # WorkflowRuntime, lazy
+
+    def _get_runtime(self) -> Any:
+        if self._runtime is None:
+            from .runtime import create_default_runtime
+
+            self._runtime = create_default_runtime()
+        return self._runtime
+
+    async def execute(
+        self,
+        run: Any = None,
+        run_context: Any = None,
+        *,
+        profile_config: ProfileConfig | None = None,
+        **kwargs: Any,
+    ) -> WorkflowResult:
+        """Run the workflow to completion and return the result.
+
+        Args:
+            run: A workspace ``Run`` object (runtime creates RunContext).
+            run_context: An existing ``RunContext`` (used directly).
+                Mutually exclusive with *run*.
+            profile_config: Active :class:`~molexp.config.ProfileConfig`
+                for this execution.  When *run_context* is passed, the
+                context's own config takes precedence.
+        """
+        return await self._get_runtime().execute(
+            self,
+            run=run,
+            run_context=run_context,
+            profile_config=profile_config,
+            **kwargs,
+        )
+
+    async def start(
+        self,
+        run: Any = None,
+        run_context: Any = None,
+        *,
+        profile_config: ProfileConfig | None = None,
+        **kwargs: Any,
+    ) -> WorkflowExecution:
+        """Start the workflow asynchronously and return a handle."""
+        return await self._get_runtime().start(
+            self,
+            run=run,
+            run_context=run_context,
+            profile_config=profile_config,
+            **kwargs,
+        )
+
+
+# ── Functional DSL ──────────────────────────────────────────────────────────
+
+
+class WorkflowDSL:
+    """Builder returned by :func:`workflow`.
+
+    Provides ``@wf.task`` and ``@wf.actor`` decorators.
+    Call ``.build()`` to produce a :class:`WorkflowSpec`.
+    """
+
+    def __init__(self, name: str, mode: str = "batch") -> None:
+        self._name = name
+        self._mode = mode
+        self._tasks: list[TaskRegistration] = []
+
+    def task(
+        self,
+        fn: Callable | None = None,
+        *,
+        depends_on: list[str] | None = None,
+        name: str | None = None,
+        remote: Any = None,
+    ) -> Callable:
+        """Register a function as a workflow task.
+
+        Usage::
+
+            @wf.task
+            async def fetch(ctx): ...
+
+            @wf.task(depends_on=["fetch"])
+            async def validate(ctx): ...
+        """
+
+        def decorator(f: Callable) -> Callable:
+            task_name = name or f.__name__
+            self._tasks.append(
+                TaskRegistration(
+                    name=task_name,
+                    fn_or_class=f,
+                    depends_on=depends_on or [],
+                    is_actor=False,
+                    remote=remote,
+                )
+            )
+            return f
+
+        if fn is not None:
+            return decorator(fn)
+        return decorator
+
+    def actor(
+        self,
+        fn: Callable | None = None,
+        *,
+        depends_on: list[str] | None = None,
+        name: str | None = None,
+    ) -> Callable:
+        """Register an async generator as a streaming actor."""
+
+        def decorator(f: Callable) -> Callable:
+            actor_name = name or f.__name__
+            self._tasks.append(
+                TaskRegistration(
+                    name=actor_name,
+                    fn_or_class=f,
+                    depends_on=depends_on or [],
+                    is_actor=True,
+                )
+            )
+            return f
+
+        if fn is not None:
+            return decorator(fn)
+        return decorator
+
+    def build(self) -> WorkflowSpec:
+        """Compile registered tasks into a :class:`WorkflowSpec`."""
+        tasks = list(self._tasks)
+        return WorkflowSpec(
+            name=self._name,
+            workflow_id=_stable_workflow_id(self._name, tasks),
+            tasks=tasks,
+            mode=self._mode,
+        )
+
+
+def workflow(name: str, mode: str = "batch") -> WorkflowDSL:
+    """Create a workflow DSL builder.
+
+    Example::
+
+        wf = workflow(name="data-pipeline")
+
+        @wf.task
+        async def fetch(ctx: TaskContext) -> FetchResult: ...
+
+        result = await wf.build().execute(run=run)
+    """
+    return WorkflowDSL(name=name, mode=mode)
+
+
+# ── OOP builder ─────────────────────────────────────────────────────────────
+
+
+class WorkflowBuilder:
+    """OOP-style builder for composing Task / Actor instances.
+
+    Example::
+
+        wf = (
+            WorkflowBuilder(name="data-pipeline")
+            .add(FetchTask())
+            .add(ValidateTask(), depends_on=["fetch"])
+            .build()
+        )
+    """
+
+    def __init__(self, name: str, mode: str = "batch") -> None:
+        self._name = name
+        self._mode = mode
+        self._tasks: list[TaskRegistration] = []
+
+    def add(
+        self,
+        task: Any,
+        *,
+        depends_on: list[str] | None = None,
+        name: str | None = None,
+        remote: Any = None,
+    ) -> WorkflowBuilder:
+        """Add a task or actor instance.
+
+        Accepts:
+        - A :class:`~Task` / :class:`~Actor` subclass instance
+        - Any object matching the :class:`~Runnable` or :class:`~Streamable` protocol
+        - A bare callable (treated as a batch task)
+        """
+        from .protocols import Streamable
+
+        task_name = name or _to_snake_case(type(task).__name__)
+        for suffix in ("_task", "_actor"):
+            if task_name.endswith(suffix):
+                task_name = task_name[: -len(suffix)]
+                break
+
+        self._tasks.append(
+            TaskRegistration(
+                name=task_name,
+                fn_or_class=task,
+                depends_on=depends_on or [],
+                is_actor=isinstance(task, Streamable),
+                remote=remote,
+            )
+        )
+        return self
+
+    def build(self) -> WorkflowSpec:
+        """Build the final :class:`WorkflowSpec`."""
+        tasks = list(self._tasks)
+        return WorkflowSpec(
+            name=self._name,
+            workflow_id=_stable_workflow_id(self._name, tasks),
+            tasks=tasks,
+            mode=self._mode,
+        )
+
+
+# ── Control-flow helpers ────────────────────────────────────────────────────
+
+
+def parallel_map(
+    wf: WorkflowDSL,
+    *,
+    fan_out_over: str,
+    depends_on: list[str] | None = None,
+    name: str | None = None,
+) -> Callable:
+    """Decorator for fan-out parallel tasks."""
+
+    def decorator(fn: Callable) -> Callable:
+        task_name = name or fn.__name__
+        wf._tasks.append(
+            TaskRegistration(
+                name=task_name,
+                fn_or_class=fn,
+                depends_on=depends_on or [],
+                is_actor=False,
+            )
+        )
+        fn._parallel_map_config = {"fan_out_over": fan_out_over}  # type: ignore[attr-defined]
+        return fn
+
+    return decorator
+
+
+def join(
+    wf: WorkflowDSL,
+    *,
+    reducer: str | Callable | None = None,
+    depends_on: list[str] | None = None,
+    name: str | None = None,
+) -> Callable:
+    """Decorator for collecting and reducing parallel outputs."""
+
+    def decorator(fn: Callable) -> Callable:
+        task_name = name or fn.__name__
+        wf._tasks.append(
+            TaskRegistration(
+                name=task_name,
+                fn_or_class=fn,
+                depends_on=depends_on or [],
+                is_actor=False,
+            )
+        )
+        fn._join_config = {"reducer": reducer}  # type: ignore[attr-defined]
+        return fn
+
+    return decorator
+
+
+# ── Helpers ─────────────────────────────────────────────────────────────────
+
+
+def _to_snake_case(name: str) -> str:
+    name = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", name)
+    name = re.sub(r"([a-z\d])([A-Z])", r"\1_\2", name)
+    return name.lower()
+
+
+def _stable_workflow_id(name: str, tasks: list[TaskRegistration]) -> str:
+    """Deterministic workflow ID from name + task topology."""
+    parts = [name]
+    for t in tasks:
+        dep_str = ",".join(sorted(t.depends_on))
+        parts.append(f"{t.name}:{type(t.fn_or_class).__qualname__}:[{dep_str}]")
+    raw = "|".join(parts)
+    return hashlib.sha256(raw.encode()).hexdigest()[:16]
diff --git a/src/molexp/workflow/status.py b/src/molexp/workflow/status.py
deleted file mode 100644
index 0f5b0f09..00000000
--- a/src/molexp/workflow/status.py
+++ /dev/null
@@ -1,16 +0,0 @@
-"""Task execution status enum."""
-
-from enum import Enum
-
-
-class TaskStatus(str, Enum):
-    """Status of a task in the workflow engine.
-
-    Inherits from str for JSON serialization compatibility.
-    """
-
-    PENDING = "pending"
-    RUNNING = "running"
-    SUCCEEDED = "succeeded"
-    FAILED = "failed"
-    CANCELLED = "cancelled"
diff --git a/src/molexp/workflow/submitor.py b/src/molexp/workflow/submitor.py
deleted file mode 100644
index 7e2d3067..00000000
--- a/src/molexp/workflow/submitor.py
+++ /dev/null
@@ -1,52 +0,0 @@
-"""Submitor protocol for external task execution."""
-
-from __future__ import annotations
-
-from typing import Protocol, Any, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from molq.resources import JobSpec
-    from molq.jobstatus import JobStatus
-
-
-class SubmitorProtocol(Protocol):
-    """Protocol for job submission backends.
-
-    This protocol defines the interface that submitors must implement
-    to be used with WorkflowEngine. It matches molq's BaseSubmitor interface.
-
-    Methods:
-        submit: Submit a job and return job ID
-        query: Query job status
-        cancel: Cancel a running job
-    """
-
-    def submit(self, config: dict | "JobSpec") -> int:
-        """Submit a job.
-
-        Args:
-            config: Job configuration as dict or JobSpec
-
-        Returns:
-            Job ID assigned by the scheduler
-        """
-        ...
-
-    def query(self, job_id: int | None = None) -> dict[int, "JobStatus"]:
-        """Query job status from the scheduler.
-
-        Args:
-            job_id: Specific job ID or None for all jobs
-
-        Returns:
-            Mapping of job IDs to JobStatus
-        """
-        ...
-
-    def cancel(self, job_id: int) -> None:
-        """Cancel a running job.
-
-        Args:
-            job_id: Job ID to cancel
-        """
-        ...
diff --git a/src/molexp/workflow/task.py b/src/molexp/workflow/task.py
index e6153992..ecd62aa8 100644
--- a/src/molexp/workflow/task.py
+++ b/src/molexp/workflow/task.py
@@ -1,326 +1,61 @@
-"""Base Task abstraction for all executable units.
+"""Convenience base classes for workflow tasks.
 
-This module provides the fundamental building blocks for workflow execution:
+``Task`` and ``Actor`` implement the :class:`~Runnable` and
+:class:`~Streamable` protocols respectively. Using them is **optional** —
+any object whose signature matches the protocol works equally well.
 
-1. **Task**: Base class for batch-style tasks that execute once and return results.
-   Tasks support local execution via execute() and external submission via submit().
+Simple (no generics)::
 
-2. **Actor**: Specialized task for continuous concurrent execution using the actor model.
-   Actors run indefinitely, communicate via message passing, and store all state in config.
+    class Square(Task):
+        async def execute(self, ctx: TaskContext) -> int:
+            return ctx.inputs ** 2
 
-The module implements a config-as-state pattern where task configuration doubles as
-runtime state, enabling hot reconfiguration and automatic persistence.
+Typed (full generics)::
 
-Example:
-    Batch task::
+    class Fetch(Task[PipeState, PipeDeps, None, DataFrame]):
+        async def execute(
+            self, ctx: TaskContext[PipeState, PipeDeps, None]
+        ) -> DataFrame:
+            return ctx.deps.storage.read(self.source)
 
-        class MyTask(Task[MyConfig, dict]):
-            config_type = MyConfig
+Third-party (no molexp import)::
 
-            def execute(self, ctx, **inputs) -> dict:
-                return {"result": self.config.value * 2}
-
-    Actor task::
-
-        class MyActor(Actor[MyConfig, dict]):
-            config_type = MyConfig
-
-            async def execute(self, ctx, **inputs) -> AsyncGenerator[None, dict]:
-                while self.config.running:
-                    data = await ctx.receive('input')
-                    await ctx.emit('output', data * 2)
-                    yield
+    # This also works in a WorkflowBuilder because it satisfies Runnable
+    class ExternalProcessor:
+        async def execute(self, ctx) -> dict: ...
 """
 
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import AsyncGenerator, Generator
-from typing import Any, Generic, Type, TypeVar, TYPE_CHECKING
-from uuid import uuid4
-
-from pydantic import BaseModel, ValidationError
-
-if TYPE_CHECKING:
-    from molq.resources import JobSpec
-    # JobHandle type - will be defined based on molq's actual return type
-    JobHandle = Any
-
-# Type variables for configuration and output
-CfgT = TypeVar("CfgT")  # Removed BaseModel bound for flexibility
-OutT = TypeVar("OutT")
-
+from typing import AsyncIterator, Generic
 
-class Task(Generic[CfgT, OutT], ABC):
-    """Base abstraction for all executable units in workflows.
+from .context import ActorContext, TaskContext
+from .types import DepsT, InputT, OutputT, StateT
 
-    A Task represents a single unit of computation that:
-    - Has a unique identifier (auto-generated)
-    - Accepts typed inputs via execute()
-    - Produces typed outputs
-    - Is configured via a Pydantic BaseModel config
-    - Can declare inputs and outputs for validation
-    - Can be tagged with a phase for workflow filtering
-    - Can be submitted to external execution backends via submit()
 
-    Tasks support two execution paths:
-    1. Local execution: execute() returns dict directly
-    2. External submission: submit() yields JobSpec, receives JobHandle, returns dict
+class Task(ABC, Generic[StateT, DepsT, InputT, OutputT]):
+    """Batch task base class (implements :class:`~Runnable` protocol).
 
-    The execution path is determined by the `submittable` attribute.
-
-    Attributes:
-        config_type: Configuration class (Pydantic BaseModel)
-        inputs: Optional dict mapping input names to types
-        outputs: Optional dict mapping output names to types
-        replayable: Whether task results can be replayed (default True)
-        phase: Optional phase tag for workflow filtering (default None).
-               Subclasses can set this to enable phase-based execution control.
-        submittable: Optional backend name for external submission (default None).
-                     If None, task executes locally via execute().
-                     If set (e.g., "molq"), task submits via submit() method.
-                     The backend name must match a registered submitor in WorkflowEngine.
-        task_id: Unique identifier (auto-generated)
-        config: Configuration instance (set at construction)
+    Subclass and implement ``execute()``.
+    Generic parameters are optional — plain ``Task`` defaults to ``Any``.
     """
 
-    # Class attributes - must be overridden by subclasses
-    config_type: Type[CfgT]
-    inputs: dict[str, type] = {}
-    outputs: dict[str, type] = {}
-    replayable: bool = True
-    phase: str | None = None
-    submittable: str | None = None
-
-    def __init__(self, **config_kwargs: Any) -> None:
-        """Initialize task with static configuration.
-
-        Args:
-            **config_kwargs: Configuration parameters
-
-        Raises:
-            ValueError: If config_kwargs don't match the config schema
-        """
-        # Auto-generate unique task ID
-        self.task_id = f"{self.__class__.__name__}_{uuid4().hex[:8]}"
-
-        # Validate config type
-        if not hasattr(self, "config_type"):
-            raise ValueError(
-                f"{self.__class__.__name__} must define a Pydantic config_type"
-            )
-        if not isinstance(self.config_type, type) or not issubclass(
-            self.config_type, BaseModel
-        ):
-            raise ValueError(
-                f"{self.__class__.__name__}.config_type must be a Pydantic BaseModel"
-            )
-
-        self.config: CfgT = self.config_type(**config_kwargs)
-
     @abstractmethod
-    def execute(self, ctx: Any | None = None, **inputs: Any) -> dict[str, Any]:
-        """Execute the task locally with given named inputs.
-
-        This is the default execution method for tasks with submittable=None.
-        Configuration is available via self.config.
-
-        Args:
-            ctx: Optional runtime context (e.g., RunContext) for accessing
-                 directories, logging, asset registration, etc.
-            **inputs: Named input values matching the task's input schema
-
-        Returns:
-            Dictionary of named outputs matching the task's output schema.
-        """
-        raise NotImplementedError
-
-    def submit(self, ctx: Any | None = None, **inputs: Any) -> Generator["JobSpec", int, dict[str, Any]]:
-        """Submit task to external execution backend via generator protocol.
-
-        This method is called for tasks with submittable != None.
-        It should yield JobSpec objects which will be submitted via the configured
-        submitor backend. The generator receives job IDs (int) back and
-        eventually returns task outputs.
-
-        Generator Protocol:
-            - Yield: JobSpec objects to submit
-            - Receive: int (job ID) for submitted jobs
-            - Return: dict of task outputs (same structure as execute())
-
-        Args:
-            ctx: Optional runtime context
-            **inputs: Named input values matching the task's input schema
-
-        Yields:
-            JobSpec: Job specification to submit
-
-        Receives:
-            int: Job ID assigned by the scheduler
-
-        Returns:
-            Dictionary of named outputs matching the task's output schema.
-
-        Raises:
-            NotImplementedError: If task has submittable set but doesn't implement this method
-
-        Example:
-            >>> def submit(self, ctx, **inputs):
-            ...     job_spec = JobSpec(
-            ...         execution=ExecutionSpec(command="python train.py"),
-            ...         resources=ResourceSpec(gpu_count=1)
-            ...     )
-            ...     job_id = yield job_spec
-            ...     return {"job_id": job_id}
-        """
-        raise NotImplementedError(
-            f"{self.__class__.__name__} has submittable='{self.submittable}' "
-            f"but does not implement submit() method. Either implement submit() "
-            f"or set submittable=None to use execute() instead."
-        )
-
-    def __call__(self, ctx: Any | None = None, **inputs: Any) -> dict[str, Any]:
-        """Callable interface - executes with stored configuration.
-
-        This allows tasks to be called directly from Python code:
-
-            task = MyTask(param1="value", param2=42)
-            result = task(input_value=10, ctx=ctx)
-
-        Args:
-            ctx: Optional runtime context
-            **inputs: Named input values
-
-        Returns:
-            Dictionary of named outputs
-        """
-        return self.execute(ctx=ctx, **inputs)
-
-    def dump(self) -> dict[str, Any]:
-        """Serialize task configuration to dictionary.
-        
-        Returns:
-            Dictionary representation of configuration
-        """
-        return self.config.model_dump()
-    
-    def compute(self, ctx: Any | None = None, **inputs: Any) -> dict[str, Any]:
-        """Alias for execute() for API consistency with molpy.Compute.
-        
-        This method delegates to execute() and is provided for API consistency.
-        
-        Args:
-            ctx: Optional runtime context
-            **inputs: Named input values
-            
-        Returns:
-            Dictionary of named outputs
-        """
-        return self.execute(ctx=ctx, **inputs)
-
-    @classmethod
-    def get_config_schema(cls) -> dict[str, Any]:
-        """Get JSON schema for this task's configuration.
-
-        Returns:
-            JSON schema dictionary, or empty dict if no schema available
-        """
-        if hasattr(cls, 'config_type') and issubclass(cls.config_type, BaseModel):
-            return cls.config_type.model_json_schema()
-        return {}
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(id={self.task_id!r}, config={self.config!r})"
-
-
-class Actor(Task[CfgT, OutT], ABC):
-    """Base class for continuous concurrent execution using the Actor model.
-
-    Actor semantics:
-    - Independent execution unit with isolated state
-    - Communicates via explicit message passing (emit/receive)
-    - Runs indefinitely until stopped or completes naturally
-    - No shared state between actors
-    - **Stateless design**: All state stored in `config` (config = state)
-
-    Framework provides ONLY this base class; users must implement domain-specific actors.
-    Actors use async generators for execution and can dynamically emit/receive messages
-    on any channel without pre-declaration.
-
-    **Config-as-State Pattern:**
-    Store all actor state in the config field. This enables:
-    - Automatic persistence via workflow metadata serialization
-    - Hot reconfiguration by updating config
-    - Easy state inspection and debugging
-
-    Example:
-        >>> class SamplerConfig(BaseModel):
-        ...     threshold: float = 0.1
-        ...     samples_collected: int = 0  # State in config
-        ...
-        >>> class SamplerActor(Actor[SamplerConfig, dict]):
-        ...     config_type = SamplerConfig
+    async def execute(self, ctx: TaskContext[StateT, DepsT, InputT]) -> OutputT:
+        """Run this task and return the output."""
         ...
-        ...     async def execute(self, ctx, **inputs) -> AsyncGenerator[None, dict]:
-        ...         while True:
-        ...             data = await ctx.receive('input')
-        ...             if data['score'] > self.config.threshold:
-        ...                 self.config.samples_collected += 1
-        ...                 await ctx.emit('output', data)
-        ...             yield
 
-    Attributes:
-        Same as Task. State should be stored in config, not as instance variables.
-    """
-
-    @abstractmethod
-    def execute(self, ctx: Any | None = None, **inputs: Any) -> AsyncGenerator[None, dict[str, Any]]:
-        """Execute actor continuously.
-
-        Actors override this method to return an AsyncGenerator instead of a dict.
-        The generator runs indefinitely, using ctx.receive() to consume messages
-        and ctx.emit() to send messages. Must yield periodically to allow asyncio
-        task switching.
-
-        **Stateless Pattern:** Store all state in self.config, check config on each
-        iteration for hot reconfiguration.
-
-        Args:
-            ctx: RunContext providing receive() and emit() for message passing
-            **inputs: Initial inputs (typically empty for actors)
-
-        Yields:
-            None (control flow, allows asyncio switching)
 
-        Returns:
-            Use ctx.set_result(task_id, result) to return final results
+class Actor(ABC, Generic[StateT, DepsT, InputT, OutputT]):
+    """Streaming actor base class (implements :class:`~Streamable` protocol).
 
-        Example:
-            >>> async def execute(self, ctx, **inputs) -> AsyncGenerator[None, dict]:
-            ...     while self.config.samples_collected < self.config.max_samples:
-            ...         data = await ctx.receive('data')
-            ...         if data['score'] > self.config.threshold:  # Check config
-            ...             self.config.samples_collected += 1
-            ...             await ctx.emit('results', data)
-            ...         yield  # Required for asyncio
-            ...
-            ...     ctx.set_result(self.task_id, {'count': self.config.samples_collected})
-            ...     return
-        """
-        raise NotImplementedError
-
-
-
-# Serialization model
-class TaskConfig(BaseModel):
-    """Serializable task configuration.
-
-    This model represents a task's configuration for serialization purposes.
-    It stores the task ID, task type (class name), and the configuration data.
+    Subclass and implement ``run()`` as an async generator.
     """
 
-    task_id: str
-    task_type: str
-    config: dict[str, Any]
-    status: str = "pending"
-    phase: str | None = None
+    @abstractmethod
+    async def run(
+        self, ctx: ActorContext[StateT, DepsT, InputT]
+    ) -> AsyncIterator[OutputT]:
+        """Run continuously, yielding outputs."""
+        ...
diff --git a/src/molexp/workflow/types.py b/src/molexp/workflow/types.py
new file mode 100644
index 00000000..c212523b
--- /dev/null
+++ b/src/molexp/workflow/types.py
@@ -0,0 +1,73 @@
+"""Core result types for molexp workflow API.
+
+Context types live in ``workflow.context``; this module holds only
+result / execution-handle types and shared type variables.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+# ── Shared type variables (re-exported by __init__) ─────────────────────────
+
+StateT = TypeVar("StateT")
+DepsT = TypeVar("DepsT")
+InputT = TypeVar("InputT")
+OutputT = TypeVar("OutputT")
+
+
+# ── Workflow execution results ──────────────────────────────────────────────
+
+
+class WorkflowResult:
+    """Result of a completed workflow execution.
+
+    Attributes:
+        status: ``"completed"`` | ``"failed"`` | ``"cancelled"``
+        outputs: Mapping of task name to task output.
+        run_id: Associated workspace Run ID, if any.
+        execution_id: Opaque ID for resumption support.
+    """
+
+    def __init__(
+        self,
+        status: str,
+        outputs: dict[str, Any],
+        run_id: str | None = None,
+        execution_id: str | None = None,
+    ) -> None:
+        self.status = status
+        self.outputs = outputs
+        self.run_id = run_id
+        self.execution_id = execution_id
+
+    def __repr__(self) -> str:
+        return (
+            f"WorkflowResult(status={self.status!r}, "
+            f"tasks={list(self.outputs.keys())})"
+        )
+
+
+class WorkflowExecution:
+    """Handle for a running workflow.
+
+    Returned by ``WorkflowSpec.start()`` for async control.
+    """
+
+    def __init__(
+        self,
+        execution_id: str,
+        workflow_id: str,
+        run_id: str | None = None,
+    ) -> None:
+        self.execution_id = execution_id
+        self.workflow_id = workflow_id
+        self.run_id = run_id
+
+    async def wait(self) -> WorkflowResult:
+        """Block until the workflow completes."""
+        raise NotImplementedError
+
+    async def cancel(self) -> None:
+        """Cancel the running workflow."""
+        raise NotImplementedError
diff --git a/src/molexp/workflow/workflow.py b/src/molexp/workflow/workflow.py
deleted file mode 100644
index c4dba968..00000000
--- a/src/molexp/workflow/workflow.py
+++ /dev/null
@@ -1,182 +0,0 @@
-"""Workflow abstraction for representing workflow graphs.
-
-This module contains the Workflow class for representing workflows as Pydantic models.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-from uuid import uuid4
-
-from pydantic import BaseModel, Field
-
-if TYPE_CHECKING:
-    from .task import Task
-
-from .link import Link
-from .registry import get_task_id, get_task_class
-from .task import TaskConfig
-
-
-class WorkflowMetadata(BaseModel):
-    """Optional metadata for workflows (uses Pydantic for validation)."""
-
-    label: str | None = None
-    description: str | None = None
-    tags: list[str] = Field(default_factory=list)
-    custom: dict[str, str | int | float | bool] = Field(default_factory=dict)
-
-
-class Workflow(BaseModel):
-    """Workflow graph containing tasks and links.
-    
-    This is the primary abstraction for workflows in molexp. Workflows are
-    Pydantic models that can be serialized to/from JSON/YAML files.
-    
-    Attributes:
-        workflow_id: Unique workflow identifier (auto-generated)
-        name: Optional workflow name
-        task_configs: List of serialized task configurations
-        links: List of Link instances between tasks
-        metadata: Optional workflow metadata
-        _tasks: Private cache of Task objects (not serialized)
-    """
-    
-    workflow_id: str = Field(default_factory=lambda: f"workflow_{uuid4().hex[:8]}")
-    name: str | None = None
-    task_configs: list[TaskConfig] = Field(default_factory=list)
-    links: list[Link] = Field(default_factory=list)
-    metadata: WorkflowMetadata = Field(default_factory=WorkflowMetadata)
-    
-    # Private runtime cache (not serialized)
-    _tasks: list[Task] | None = None
-    
-    model_config = {"arbitrary_types_allowed": True}
-    
-    @classmethod
-    def from_tasks(
-        cls,
-        tasks: list[Task],
-        links: list[Link],
-        name: str | None = None,
-    ) -> Workflow:
-        """Build Workflow from Task objects.
-        
-        Args:
-            tasks: List of Task instances
-            links: List of Link instances
-            name: Optional workflow name
-            
-        Returns:
-            Workflow instance with tasks serialized to task_configs
-        """
-        task_configs = []
-        for task in tasks:
-            # Try to get registered task_type_id; fall back for unregistered tasks
-            try:
-                task_type_id = get_task_id(task.__class__)
-            except (KeyError, ValueError):
-                # Unregistered task — use class name as placeholder.
-                # The workflow can still be executed immediately but not
-                # deserialized from disk without registration.
-                task_type_id = task.__class__.__qualname__
-            phase = getattr(task, "phase", None)
-            task_configs.append(
-                TaskConfig(
-                    task_id=task.task_id,
-                    task_type=task_type_id,
-                    config=task.config.model_dump(),
-                    phase=phase,
-                )
-            )
-        
-        workflow = cls(
-            name=name,
-            task_configs=task_configs,
-            links=links,
-        )
-        workflow._tasks = tasks  # Cache runtime objects
-        return workflow
-    
-    def get_tasks(self) -> list[Task]:
-        """Get or restore Task objects.
-        
-        Returns:
-            List of Task instances
-        """
-        if self._tasks is not None:
-            return self._tasks
-        
-        # Restore tasks from configs using global registry
-        tasks = []
-        for task_config in self.task_configs:
-            task_class = get_task_class(task_config.task_type)
-            task = task_class(**task_config.config)
-            task.task_id = task_config.task_id  # Restore ID
-            tasks.append(task)
-        
-        self._tasks = tasks  # Cache
-        return tasks
-    
-    def save(self, path: Path, format: str = "auto") -> None:
-        """Save workflow to file.
-        
-        Args:
-            path: Path to save the workflow
-            format: File format ('json', 'yaml', or 'auto' to detect from extension)
-            
-        Raises:
-            ValueError: If format is unsupported
-        """
-        if format == "auto":
-            format = "yaml" if path.suffix in (".yaml", ".yml") else "json"
-        
-        if format == "json":
-            content = self.model_dump_json(indent=2, exclude={"_tasks"})
-        elif format == "yaml":
-            import yaml
-            content = yaml.dump(
-                self.model_dump(exclude={"_tasks"}),
-                default_flow_style=False,
-                sort_keys=False,
-            )
-        else:
-            raise ValueError(f"Unsupported format: {format}. Use 'json' or 'yaml'.")
-        
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(content)
-    
-    @classmethod
-    def load(cls, path: Path) -> Workflow:
-        """Load workflow from file.
-        
-        Args:
-            path: Path to the workflow file
-            
-        Returns:
-            Workflow instance
-            
-        Raises:
-            FileNotFoundError: If file doesn't exist
-            ValueError: If file extension is unsupported
-        """
-        if not path.exists():
-            raise FileNotFoundError(f"Workflow file not found: {path}")
-        
-        content = path.read_text()
-        
-        if path.suffix == ".json":
-            return cls.model_validate_json(content)
-        elif path.suffix in (".yaml", ".yml"):
-            import yaml
-            data = yaml.safe_load(content)
-            return cls.model_validate(data)
-        else:
-            raise ValueError(
-                f"Unsupported file extension: {path.suffix}. "
-                f"Use .json, .yaml, or .yml"
-            )
-    
-    def __repr__(self) -> str:
-        return f"Workflow(id={self.workflow_id!r}, tasks={len(self.task_configs)}, links={len(self.links)})"
diff --git a/src/molexp/workspace/__init__.py b/src/molexp/workspace/__init__.py
index 0d47c9f8..f99948a7 100644
--- a/src/molexp/workspace/__init__.py
+++ b/src/molexp/workspace/__init__.py
@@ -1,32 +1,51 @@
-"""Workspace module exports."""
+"""Workspace module — file-system-backed experiment management.
+
+Hierarchy: Workspace -> Project -> Experiment -> Run
+Each level owns an AssetLibrary for scoped artifact storage.
+"""
 
-from .workspace import Workspace
-from .project import Project
-from .experiment import Experiment
-from .run import Run, RunStatus, RunContext
-from .context import Context
 from .asset import Asset, AssetLibrary, AssetWorkflow
-from .metadata import (
-    WorkspaceMetadata,
-    ProjectMetadata,
+from .context import Context
+from .experiment import Experiment
+from .models import (
+    ErrorInfo,
+    ExecutionRecord,
     ExperimentMetadata,
+    ProjectMetadata,
     RunMetadata,
+    WorkflowSnapshotRef,
+    WorkspaceMetadata,
 )
-
+from .param import GridSpace, Params, ParamSpace, UniformSpace
+from .project import Project
+from .run import Run, RunContext, RunStatus
+from .workspace import Workspace
 
 __all__ = [
+    # Entities
     "Workspace",
     "Project",
     "Experiment",
     "Run",
-    "RunStatus",
     "RunContext",
-    "Context",
-    "Asset",
-    "AssetLibrary",
-    "AssetWorkflow",
+    "RunStatus",
+    # Metadata models
     "WorkspaceMetadata",
     "ProjectMetadata",
     "ExperimentMetadata",
     "RunMetadata",
+    "ExecutionRecord",
+    "ErrorInfo",
+    "WorkflowSnapshotRef",
+    # Assets
+    "Asset",
+    "AssetLibrary",
+    "AssetWorkflow",
+    # Parameters
+    "ParamSpace",
+    "Params",
+    "GridSpace",
+    "UniformSpace",
+    # Context
+    "Context",
 ]
diff --git a/src/molexp/workspace/__pycache__/__init__.cpython-312.pyc b/src/molexp/workspace/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index a1824659..00000000
Binary files a/src/molexp/workspace/__pycache__/__init__.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workspace/__pycache__/core.cpython-312.pyc b/src/molexp/workspace/__pycache__/core.cpython-312.pyc
deleted file mode 100644
index 1bdc2c22..00000000
Binary files a/src/molexp/workspace/__pycache__/core.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workspace/__pycache__/scanner.cpython-312.pyc b/src/molexp/workspace/__pycache__/scanner.cpython-312.pyc
deleted file mode 100644
index e7294354..00000000
Binary files a/src/molexp/workspace/__pycache__/scanner.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workspace/__pycache__/validator.cpython-312.pyc b/src/molexp/workspace/__pycache__/validator.cpython-312.pyc
deleted file mode 100644
index a1c91eb6..00000000
Binary files a/src/molexp/workspace/__pycache__/validator.cpython-312.pyc and /dev/null differ
diff --git a/src/molexp/workspace/asset.py b/src/molexp/workspace/asset.py
index 00c32567..8623c084 100644
--- a/src/molexp/workspace/asset.py
+++ b/src/molexp/workspace/asset.py
@@ -14,7 +14,7 @@
 from pathlib import Path
 from typing import Any, Callable, Literal
 
-from pydantic import BaseModel, Field, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 from .utils import generate_asset_id
 
diff --git a/src/molexp/workspace/base.py b/src/molexp/workspace/base.py
index 575254b1..4eeaff38 100644
--- a/src/molexp/workspace/base.py
+++ b/src/molexp/workspace/base.py
@@ -7,7 +7,8 @@
 from __future__ import annotations
 
 import json
-from datetime import datetime
+import os
+import tempfile
 from pathlib import Path
 from typing import Any, TypeVar
 
@@ -16,15 +17,43 @@
 T = TypeVar("T")
 
 
+def _atomic_write_json(path: Path, data: Any) -> None:
+    """Write JSON data to a file atomically via write-to-temp + rename.
+
+    On POSIX systems, os.replace is atomic — if the process crashes mid-write,
+    the original file remains intact. This prevents data corruption for
+    critical files like run.json and metadata files.
+
+    Args:
+        path: Destination file path.
+        data: JSON-serializable data to write.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # Write to a temp file in the same directory (same filesystem for atomic rename)
+    fd, tmp_path = tempfile.mkstemp(
+        dir=path.parent, suffix=".tmp", prefix=f".{path.stem}_"
+    )
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(data, f, indent=2, default=str)
+        os.replace(tmp_path, path)
+    except BaseException:
+        # Clean up temp file on any failure (including KeyboardInterrupt)
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
 def _save_metadata(metadata: BaseModel, path: Path) -> None:
-    """Write a Pydantic metadata model to a JSON file.
+    """Write a Pydantic metadata model to a JSON file atomically.
 
     Args:
         metadata: Pydantic model to serialize.
         path: Destination file path.
     """
-    with open(path, "w") as f:
-        json.dump(metadata.model_dump(mode="json"), f, indent=2, default=str)
+    _atomic_write_json(path, metadata.model_dump(mode="json"))
 
 
 def _load_metadata(metadata_cls: type[T], path: Path) -> T:
diff --git a/src/molexp/workspace/checkpoint.py b/src/molexp/workspace/checkpoint.py
index 421dd1c0..03fd3618 100644
--- a/src/molexp/workspace/checkpoint.py
+++ b/src/molexp/workspace/checkpoint.py
@@ -10,12 +10,12 @@
 import uuid
 from datetime import datetime
 from pathlib import Path
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel, Field
 
 if TYPE_CHECKING:
-    from .context import Context
+    pass
 
 
 class CheckpointState(BaseModel):
diff --git a/src/molexp/workspace/context.py b/src/molexp/workspace/context.py
index 9d5fd114..70adc3e9 100644
--- a/src/molexp/workspace/context.py
+++ b/src/molexp/workspace/context.py
@@ -19,7 +19,8 @@ class Context(BaseModel):
         experiment_id: Experiment identifier
         project_id: Project identifier
         work_dir: Working directory path
-        artifacts_dir: Artifacts directory path
+        artifacts_dir: User-saved outputs (model files, predictions, metrics, etc.)
+        logs_dir: Runtime-generated logs (error traces, TensorBoard events, etc.)
         tasks: Task execution statuses
         results: Execution results
         status: Overall execution status
@@ -27,14 +28,15 @@ class Context(BaseModel):
         workflow: Serialized workflow data
         execution: Submission metadata and job tracking
     """
-    
+
     run_id: str
     experiment_id: str
     project_id: str
     work_dir: Path
     artifacts_dir: Path
+    logs_dir: Path
     tasks: dict[str, str] = Field(default_factory=dict)
-    results: dict[str, dict] = Field(default_factory=dict)
+    results: dict[str, Any] = Field(default_factory=dict)
     status: dict = Field(default_factory=dict)
     errors: dict[str, dict] = Field(default_factory=dict)
     workflow: dict[str, Any] | None = None
diff --git a/src/molexp/workspace/experiment.py b/src/molexp/workspace/experiment.py
index bfb0a5f4..0810e1fe 100644
--- a/src/molexp/workspace/experiment.py
+++ b/src/molexp/workspace/experiment.py
@@ -1,12 +1,19 @@
-"""Experiment entity with run management.
+"""Experiment entity — one directory per parameter combination.
 
-An Experiment represents a research experiment with runtime behavior and references.
-Construction auto-generates metadata; persistence happens via materialize().
+An Experiment binds a workflow to a concrete set of parameters plus a
+replica configuration (``n_replicas`` × ``seeds``).  Replicas under the
+same Experiment share parameters; they differ only in their random seed.
+
+Construction is side-effect free; ``project.experiment(...)`` materializes
+on disk at call-time (idempotent: if an experiment with the same slug
+already exists, it is loaded and returned).
 """
 
 from __future__ import annotations
 
-from datetime import datetime
+import asyncio
+import inspect
+from collections.abc import Callable
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -14,233 +21,243 @@
     from .project import Project
     from .workspace import Workspace
 
-from .base import _save_metadata, _load_metadata, _reconstruct, _list_children
-from .metadata import ExperimentMetadata, RunMetadata
+from molexp.workflow.context import TaskContext
+from molexp.workflow.spec import WorkflowBuilder, WorkflowSpec
+from molexp.workflow.task import Task
+
+from .asset import AssetLibrary
+from .base import _list_children, _load_metadata, _reconstruct, _save_metadata
+from .models import ExperimentMetadata, RunMetadata, WorkflowSnapshotRef
 from .run import Run
 from .utils import generate_id
 
 
+# Default replica seeds — deterministic, well-separated
+_DEFAULT_SEEDS = [42, 123, 456, 789, 1234]
+
+
+class _EntryTask(Task):
+    """Wraps a bare ``fn(RunContext) -> None`` into a workflow Task."""
+
+    def __init__(self, fn: Callable) -> None:
+        self._fn = fn
+
+    async def execute(self, ctx: TaskContext) -> None:
+        run_ctx = ctx.run_context
+        if run_ctx is None:
+            raise RuntimeError(
+                f"{self._fn.__name__}() requires a RunContext, but the "
+                "workflow was executed without a workspace run."
+            )
+        result = self._fn(run_ctx)
+        if asyncio.iscoroutine(result) or inspect.isawaitable(result):
+            await result
+
+
+def _promote_to_workflow(fn: Callable, name: str) -> WorkflowSpec:
+    """Promote a bare ``fn(RunContext)`` to a single-Task WorkflowSpec."""
+    return WorkflowBuilder(name=name).add(_EntryTask(fn), name=fn.__name__).build()
+
+
 class Experiment:
-    """Research experiment container with runtime behavior.
-    
-    Construction is side-effect free and auto-generates metadata.
-    Filesystem operations happen explicitly via materialize().
-    
-    Example:
-        >>> # User provides only what they care about
-        >>> experiment = Experiment(
-        ...     name="Hyperparameter Search",
-        ...     project=project
-        ... )
-        >>> 
-        >>> # System fields auto-generated
-        >>> assert experiment.id  # UUID auto-generated
-        >>> assert experiment.metadata.created_at  # Timestamp auto-generated
-        >>> 
-        >>> # Workspace accessed via project (respects hierarchy)
-        >>> assert experiment.workspace is project.workspace
-        >>> 
-        >>> # No filesystem side effects yet
-        >>> # Explicitly materialize to disk
-        >>> experiment.materialize()  # NOW directories/files are created
+    """Repeatable experiment bound to a workflow and a concrete parameter set.
+
+    Example::
+
+        exp = project.experiment(
+            "lr-1e-3",
+            params={"lr": 1e-3},
+            n_replicas=3,
+        )
+        exp.set_workflow(train_fn)
     """
-    
+
     def __init__(
         self,
         name: str,
         project: Project,
         id: str | None = None,
-    ):
-        """Initialize experiment with user inputs and auto-generate metadata.
-
-        Args:
-            name: Human-readable experiment name (user input)
-            project: Parent project (runtime dependency)
-            id: Optional custom ID (if None, auto-generates UUID)
-        """
+        *,
+        params: dict[str, Any] | None = None,
+        n_replicas: int = 1,
+        seeds: list[int] | None = None,
+        workflow_source: str | None = None,
+        workflow_type: str | None = None,
+        git_commit: str | None = None,
+    ) -> None:
         self.project = project
-
-        # Auto-generate metadata with system fields
         self.metadata = ExperimentMetadata(
             id=id if id is not None else generate_id(),
             name=name,
-            created_at=datetime.now(),  # Auto-generated timestamp
-            updated_at=datetime.now(),
-            description="",
-            tags=[],
-            config={},
+            workflow_source=workflow_source,
+            workflow_type=workflow_type,
+            parameter_space=dict(params) if params else {},
+            git_commit=git_commit,
+            n_replicas=n_replicas,
+            seeds=list(seeds) if seeds is not None else None,
         )
-        
-        # Runtime-only cache
-        self._assets_lib = None
-    
-    # Property proxies for convenient access to metadata fields
-    
+        self._assets_lib: AssetLibrary | None = None
+        self._workflow: WorkflowSpec | None = None
+
+    # ── Properties ──────────────────────────────────────────────────────
+
     @property
     def id(self) -> str:
-        """Experiment identifier."""
         return self.metadata.id
-    
+
     @property
     def name(self) -> str:
-        """Human-readable experiment name."""
         return self.metadata.name
-    
+
     @property
     def created_at(self):
-        """Creation timestamp."""
         return self.metadata.created_at
-    
-    @property
-    def updated_at(self):
-        """Last update timestamp."""
-        return self.metadata.updated_at
-    
+
     @property
     def description(self) -> str:
-        """Experiment description."""
         return self.metadata.description
 
     @property
     def tags(self) -> list[str]:
-        """Experiment tags."""
         return self.metadata.tags
 
     @property
-    def config(self) -> dict[str, Any]:
-        """Experiment configuration."""
-        return self.metadata.config
-    
+    def workflow_source(self) -> str | None:
+        return self.metadata.workflow_source
+
+    @property
+    def parameter_space(self) -> dict[str, Any]:
+        return self.metadata.parameter_space
+
+    @property
+    def params(self) -> dict[str, Any]:
+        """Concrete parameter dict bound to this experiment."""
+        return self.metadata.parameter_space
+
+    @property
+    def n_replicas(self) -> int:
+        return self.metadata.n_replicas
+
+    @property
+    def seeds(self) -> list[int] | None:
+        return self.metadata.seeds
+
+    @property
+    def workflow(self) -> WorkflowSpec | None:
+        """The bound workflow (always ``WorkflowSpec`` or ``None``)."""
+        return self._workflow
+
     @property
     def workspace(self) -> Workspace:
-        """Access workspace through project (respects hierarchy)."""
         return self.project.workspace
-    
+
     @property
-    def assets(self):
-        """Experiment-level asset library."""
-        from .asset import AssetLibrary
-        
-        assets_dir = (
-            self.workspace.root / "projects" / self.project.id / 
-            "experiments" / self.id / "assets"
-        )
+    def experiment_dir(self) -> Path:
+        return self.project.project_dir / "experiments" / self.id
+
+    @property
+    def assets(self) -> AssetLibrary:
         if self._assets_lib is None:
-            self._assets_lib = AssetLibrary(assets_dir)
+            self._assets_lib = AssetLibrary(self.experiment_dir / "assets")
         return self._assets_lib
-    
-    def materialize(self) -> None:
-        """Create filesystem structure and persist metadata.
 
-        This is the explicit side-effect method that:
-        - Creates experiment directory
-        - Writes metadata JSON file
-        - Initializes subdirectories (assets, runs)
-        """
-        experiment_dir = (
-            self.workspace.root / "projects" / self.project.id /
-            "experiments" / self.id
-        )
-        experiment_dir.mkdir(parents=True, exist_ok=True)
-        _save_metadata(self.metadata, experiment_dir / "experiment.json")
-    
-    def save(self) -> None:
-        """Save updated metadata to disk."""
-        experiment_dir = (
-            self.workspace.root / "projects" / self.project.id /
-            "experiments" / self.id
-        )
-        self.metadata.updated_at = datetime.now()
-        _save_metadata(self.metadata, experiment_dir / "experiment.json")
-    
-    def create_run(self, parameters: dict[str, Any] | None = None, id: str | None = None, exist_ok: bool = False) -> Run:
-        """Create run in this experiment.
+    # ── Workflow binding ────────────────────────────────────────────────
 
-        Args:
-            parameters: Run parameters (user input)
-            id: Optional custom run ID (if None, auto-generates UUID)
-            exist_ok: If True, always create new run (runs don't have names to match by)
-                     Only useful with custom id to load existing run by ID
+    def set_workflow(self, workflow: WorkflowSpec | Callable) -> None:
+        """Bind a workflow to this experiment.
 
-        Returns:
-            Created Run (already materialized)
+        Accepts a compiled :class:`WorkflowSpec` or a bare ``fn(RunContext)``
+        callable; callables are auto-promoted to a single-Task ``WorkflowSpec``.
 
         Raises:
-            ValueError: If run with this ID already exists and exist_ok=False
+            TypeError: If *workflow* is not a ``WorkflowSpec`` or callable.
+            ValueError: If a workflow is already bound.
+        """
+        if self._workflow is not None:
+            raise ValueError(
+                f"Experiment {self.name!r} already has a workflow bound."
+            )
+        if isinstance(workflow, WorkflowSpec):
+            self._workflow = workflow
+        elif callable(workflow):
+            self._workflow = _promote_to_workflow(workflow, self.name)
+        else:
+            raise TypeError(
+                f"Expected WorkflowSpec or callable, got {type(workflow).__name__}"
+            )
+
+    def get_seeds(self) -> list[int]:
+        """Return replica seeds (length == ``n_replicas``)."""
+        seeds = self.metadata.seeds
+        if seeds is not None:
+            return list(seeds[: self.n_replicas])
+        out = list(_DEFAULT_SEEDS)
+        while len(out) < self.n_replicas:
+            out.append(out[-1] + 111)
+        return out[: self.n_replicas]
+
+    # ── Persistence ─────────────────────────────────────────────────────
+
+    def materialize(self) -> None:
+        """Create filesystem structure and persist metadata (non-recursive)."""
+        self.experiment_dir.mkdir(parents=True, exist_ok=True)
+        _save_metadata(self.metadata, self.experiment_dir / "experiment.json")
+
+    def save(self) -> None:
+        """Persist current metadata to disk."""
+        _save_metadata(self.metadata, self.experiment_dir / "experiment.json")
+
+    # ── Run operations ──────────────────────────────────────────────────
 
-        Note:
-            Unlike create_project/create_experiment, runs don't have unique names,
-            so exist_ok only works when a custom id is provided. Without custom id,
-            a new run is always created (since each run should represent a new execution).
+    def run(
+        self,
+        parameters: dict[str, Any] | None = None,
+        *,
+        id: str | None = None,
+    ) -> Run:
+        """Get-or-create a run (idempotent, materialized immediately).
+
+        If a run with the same ID already exists on disk, load and return it.
+        Otherwise, construct + materialize a new Run.
         """
-        # Construct run (no side effects)
-        run = Run(
+        snapshot = None
+        if self.metadata.workflow_source:
+            snapshot = WorkflowSnapshotRef(
+                source=self.metadata.workflow_source,
+                git_commit=self.metadata.git_commit,
+            )
+
+        r = Run(
             experiment=self,
             parameters=parameters,
             id=id,
+            workflow_snapshot=snapshot,
         )
-
-        # Check if run already exists by ID
-        run_dir = (
-            self.workspace.root / "projects" / self.project.id /
-            "experiments" / self.id / "runs" / run.id
-        )
+        run_dir = self.experiment_dir / "runs" / f"run-{r.id}"
         if run_dir.exists():
-            if exist_ok:
-                # Load existing run
-                metadata_file = run_dir / "run.json"
-                if metadata_file.exists():
-                    from .base import _load_metadata, _reconstruct
-                    from .metadata import RunMetadata
-                    metadata = _load_metadata(RunMetadata, metadata_file)
-                    attrs = {
-                        'metadata': metadata,
-                        'experiment': self,
-                    }
-                    return _reconstruct(Run, attrs)
-            raise ValueError(f"Run '{run.id}' already exists")
-
-        # Explicitly materialize
-        run.materialize()
-
-        return run
-    
-    def get_run(self, run_id: str) -> Run | None:
-        """Get run by ID (load from disk).
-
-        Args:
-            run_id: Run UUID
-
-        Returns:
-            Run object if found, None otherwise
-        """
-        run_dir = (
-            self.workspace.root / "projects" / self.project.id / "experiments" /
-            self.id / "runs" / run_id
-        )
+            return self._load_run_from_dir(run_dir)
+        r.materialize()
+        return r
 
+    def get_run(self, run_id: str) -> Run | None:
+        """Get run by ID."""
+        run_dir = self.experiment_dir / "runs" / f"run-{run_id}"
         if not run_dir.exists():
             return None
+        return self._load_run_from_dir(run_dir)
 
-        metadata = _load_metadata(RunMetadata, run_dir / "run.json")
-        return _reconstruct(Run, {
-            "experiment": self,
-            "metadata": metadata,
-        })
-    
     def list_runs(self) -> list[Run]:
-        """List runs in this experiment.
-
-        Returns:
-            List of Run objects
-        """
+        """List all runs by scanning the ``runs/`` directory."""
         return _list_children(
-            children_dir=(
-                self.workspace.root / "projects" / self.project.id / "experiments" /
-                self.id / "runs"
-            ),
+            children_dir=self.experiment_dir / "runs",
             metadata_filename="run.json",
             metadata_cls=RunMetadata,
             child_cls=Run,
             attrs_factory=lambda m: {"experiment": self, "metadata": m},
         )
+
+    # ── Internal ────────────────────────────────────────────────────────
+
+    def _load_run_from_dir(self, run_dir: Path) -> Run:
+        meta = _load_metadata(RunMetadata, run_dir / "run.json")
+        return _reconstruct(Run, {"experiment": self, "metadata": meta})
diff --git a/src/molexp/workspace/metadata.py b/src/molexp/workspace/metadata.py
deleted file mode 100644
index 583f2cf5..00000000
--- a/src/molexp/workspace/metadata.py
+++ /dev/null
@@ -1,98 +0,0 @@
-"""Metadata models for workspace entities.
-
-This module defines plain data models for persistence. These models:
-- Contain only serializable fields
-- Have no Python object references
-- Perform no side effects during validation
-- Support round-trip JSON serialization
-
-The metadata models represent the minimal declarative state required to
-persist workspace entities across process boundaries.
-"""
-
-from __future__ import annotations
-
-from datetime import datetime
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-
-class WorkspaceMetadata(BaseModel):
-    """Serializable workspace metadata.
-
-    Contains only essential fields that must persist across process boundaries.
-    No runtime references or computed properties.
-    """
-
-    id: str = Field(..., description="Workspace identifier")
-    name: str = Field(..., description="Human-readable workspace name")
-    created_at: datetime = Field(default_factory=datetime.now)
-    updated_at: datetime = Field(default_factory=datetime.now)
-    projects: list[str] = Field(default_factory=list, description="List of project IDs")
-
-
-class ProjectMetadata(BaseModel):
-    """Serializable project metadata.
-
-    Contains only essential fields that must persist across process boundaries.
-    No runtime references or computed properties.
-    """
-
-    id: str = Field(..., description="Project identifier")
-    name: str = Field(..., description="Human-readable project name")
-    created_at: datetime = Field(default_factory=datetime.now)
-    updated_at: datetime = Field(default_factory=datetime.now)
-    description: str = Field(default="", description="Project description")
-    owner: str = Field(default="", description="Project owner")
-    tags: list[str] = Field(default_factory=list, description="Project tags")
-    config: dict[str, Any] = Field(default_factory=dict, description="Project configuration")
-    experiments: list[str] = Field(default_factory=list, description="List of experiment IDs")
-    assets: list[str] = Field(default_factory=list, description="List of asset names")
-
-
-class ExperimentMetadata(BaseModel):
-    """Serializable experiment metadata.
-    
-    Contains only essential fields that must persist across process boundaries.
-    No runtime references or computed properties.
-    """
-    
-    id: str = Field(..., description="Experiment identifier (UUID)")
-    name: str = Field(..., description="Human-readable experiment name")
-    created_at: datetime = Field(default_factory=datetime.now)
-    updated_at: datetime = Field(default_factory=datetime.now)
-    description: str = Field(default="", description="Experiment description")
-    tags: list[str] = Field(default_factory=list, description="Experiment tags")
-    config: dict[str, Any] = Field(default_factory=dict, description="Experiment configuration")
-
-
-class RunMetadata(BaseModel):
-    """Serializable run metadata.
-    
-    Contains only essential fields that must persist across process boundaries.
-    No runtime references or computed properties.
-    
-    Includes run-specific fields like parameters and assets.
-    """
-    
-    id: str = Field(..., description="Run identifier (UUID)")
-    parameters: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Execution parameters"
-    )
-    assets: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Input/output assets and artifacts"
-    )
-    created_at: datetime = Field(default_factory=datetime.now)
-    updated_at: datetime = Field(default_factory=datetime.now)
-    status: str = Field(default="pending", description="Run status")
-    finished_at: datetime | None = Field(default=None, description="Completion timestamp")
-    
-    # Error summary (for quick indexing)
-    error: dict[str, str] | None = Field(
-        default=None,
-        description="Error summary: type, message, timestamp"
-    )
-
diff --git a/src/molexp/workspace/models.py b/src/molexp/workspace/models.py
new file mode 100644
index 00000000..3a16a5c6
--- /dev/null
+++ b/src/molexp/workspace/models.py
@@ -0,0 +1,139 @@
+"""Domain models for workspace entities.
+
+This module is the single source of truth for workspace entity schemas.
+The server, CLI, and Python API all derive from these models.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+# ── Shared value objects ────────────────────────────────────────────────────
+
+
+class ErrorInfo(BaseModel, frozen=True):
+    """Structured error summary attached to a failed run."""
+
+    type: str
+    message: str
+    timestamp: datetime
+
+
+class WorkflowSnapshotRef(BaseModel, frozen=True):
+    """Frozen reference to the workflow that produced a run.
+
+    Captured at run-creation time so the exact code/config
+    can always be traced back.
+    """
+
+    source: str
+    git_commit: str | None = None
+    code_hash: str | None = None
+    config_hash: str | None = None
+
+
+# ── Entity metadata ────────────────────────────────────────────────────────
+#
+# Design rules:
+#   1. Every model is frozen.  Updates go through model_copy(update={...}).
+#   2. Parents never store child lists.  ``list_projects()`` scans the
+#      filesystem; directory presence is the only truth.
+#   3. No ``updated_at``.  If you need "last modified", read the file mtime.
+
+
+class WorkspaceMetadata(BaseModel, frozen=True):
+    """Top-level workspace."""
+
+    id: str
+    name: str
+    created_at: datetime = Field(default_factory=datetime.now)
+
+
+class ProjectMetadata(BaseModel, frozen=True):
+    """Research project container."""
+
+    id: str
+    name: str
+    description: str = ""
+    owner: str = ""
+    tags: list[str] = Field(default_factory=list)
+    config: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=datetime.now)
+
+
+class ExperimentMetadata(BaseModel, frozen=True):
+    """Repeatable experiment definition bound to a workflow.
+
+    An Experiment carries a concrete parameter dict (`parameter_space`)
+    plus replica configuration (`n_replicas`, `seeds`).  Parameter sweeps
+    are expanded by the user at script level (e.g. via ``for p in GridSpace(...)``);
+    each combination becomes a distinct Experiment.  Replicas under a
+    single Experiment share parameters but differ in random seed.
+    """
+
+    id: str
+    name: str
+    description: str = ""
+    tags: list[str] = Field(default_factory=list)
+    created_at: datetime = Field(default_factory=datetime.now)
+
+    # Workflow binding — what makes an Experiment more than just a folder
+    workflow_source: str | None = None
+    workflow_type: str | None = None
+    parameter_space: dict[str, Any] = Field(default_factory=dict)
+    git_commit: str | None = None
+
+    # Replica configuration
+    n_replicas: int = 1
+    seeds: list[int] | None = None
+
+
+class ExecutionRecord(BaseModel, frozen=True):
+    """One attempt to execute a Run.
+
+    A Run may be executed multiple times (e.g. retries after failure).
+    Each attempt is recorded here so the full execution history is
+    queryable from run.json without scanning execution sub-directories.
+    """
+
+    execution_id: str
+    started_at: datetime
+    finished_at: datetime | None = None
+    status: str = "running"
+    molq_job_id: str | None = None
+    scheduler_job_id: str | None = None
+
+
+class RunMetadata(BaseModel):
+    """Single execution instance metadata.
+
+    ``profile`` is the activated molcfg profile name (normalized,
+    ``-`` → ``_``) or ``None`` when no profile was selected.  ``config``
+    is the frozen merged configuration dict that the run executed
+    against; ``config_hash`` is its sha256 digest, duplicated for fast
+    queryability.  The framework treats profile contents as opaque
+    user data — it persists them for reproducibility but never
+    interprets them.
+
+    ``execution_history`` indexes every attempt to execute this run,
+    newest last.  Each entry points to the corresponding sub-directory
+    under ``run_dir/execution/``.
+    """
+
+    id: str
+    status: str = "pending"
+    parameters: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=datetime.now)
+    finished_at: datetime | None = None
+    error: ErrorInfo | None = None
+    workflow_snapshot: WorkflowSnapshotRef | None = None
+    script: str | None = None
+    profile: str | None = None
+    config: dict[str, Any] = Field(default_factory=dict)
+    config_hash: str | None = None
+    labels: dict[str, str] = Field(default_factory=dict)
+    executor_info: dict[str, Any] = Field(default_factory=dict)
+    execution_history: list[ExecutionRecord] = Field(default_factory=list)
diff --git a/src/molexp/workspace/param.py b/src/molexp/workspace/param.py
new file mode 100644
index 00000000..98e4fc01
--- /dev/null
+++ b/src/molexp/workspace/param.py
@@ -0,0 +1,106 @@
+"""Parameter spaces for experiment hyperparameter search.
+
+Provides:
+- ParamSpace: abstract base class
+- GridSpace: exhaustive Cartesian product
+- UniformSpace: uniform random sampling
+"""
+
+from __future__ import annotations
+
+import random
+from abc import ABC, abstractmethod
+from collections.abc import Generator
+from itertools import product
+from typing import Any
+
+Params = dict[str, Any]
+
+
+class ParamSpace(ABC):
+    """Abstract base class for parameter spaces.
+
+    A parameter space defines how to generate parameter combinations
+    for hyperparameter search.
+    """
+
+    @abstractmethod
+    def __iter__(self) -> Generator[Params, None, None]:
+        """Generate parameter combinations."""
+        ...
+
+    @abstractmethod
+    def __len__(self) -> int:
+        """Return the total number of parameter combinations."""
+        ...
+
+    def count(self) -> int:
+        """Alias for len()."""
+        return len(self)
+
+
+class GridSpace(ParamSpace):
+    """Exhaustive Cartesian product over all parameter values.
+
+    Example::
+
+        space = GridSpace({"lr": [1e-4, 5e-4], "batch": [32, 64]})
+        # yields 4 combinations
+    """
+
+    def __init__(self, param_grid: dict[str, list[Any]]) -> None:
+        self.param_grid = param_grid
+        self._param_names = list(param_grid.keys())
+        self._param_values = list(param_grid.values())
+        self._total = 1
+        for values in self._param_values:
+            self._total *= len(values)
+
+    def __iter__(self) -> Generator[Params, None, None]:
+        for combination in product(*self._param_values):
+            yield dict(zip(self._param_names, combination))
+
+    def __len__(self) -> int:
+        return self._total
+
+    def __repr__(self) -> str:
+        return f"GridSpace({len(self)} combinations)"
+
+
+class UniformSpace(ParamSpace):
+    """Uniform random sampling from discrete value lists.
+
+    Example::
+
+        space = UniformSpace({"lr": [1e-4, 5e-4, 1e-3]}, n_samples=20, seed=42)
+    """
+
+    def __init__(
+        self,
+        param_values: dict[str, list[Any]],
+        n_samples: int,
+        seed: int | None = None,
+    ) -> None:
+        self.param_values = param_values
+        self.n_samples = n_samples
+        self.seed = seed
+
+    def __iter__(self) -> Generator[Params, None, None]:
+        rng = random.Random(self.seed)
+        for _ in range(self.n_samples):
+            params: Params = {}
+            for name, values in self.param_values.items():
+                if not isinstance(values, list):
+                    raise ValueError(
+                        f"Parameter '{name}' must be a list, got {type(values)}"
+                    )
+                if len(values) == 0:
+                    raise ValueError(f"Parameter '{name}' must have at least one value")
+                params[name] = rng.choice(values)
+            yield params
+
+    def __len__(self) -> int:
+        return self.n_samples
+
+    def __repr__(self) -> str:
+        return f"UniformSpace({self.n_samples} samples, seed={self.seed})"
diff --git a/src/molexp/workspace/project.py b/src/molexp/workspace/project.py
index 009217e2..89acfc83 100644
--- a/src/molexp/workspace/project.py
+++ b/src/molexp/workspace/project.py
@@ -1,351 +1,184 @@
 """Project entity with experiment management.
 
-A Project represents a research project with runtime behavior and references.
-Construction auto-generates metadata; persistence happens via materialize().
+Construction is side-effect free; ``workspace.project(...)`` materializes
+on disk at call-time (idempotent: existing projects are loaded, missing
+ones are created).
 """
 
 from __future__ import annotations
 
-from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from .workspace import Workspace
 
-from .base import _save_metadata, _load_metadata, _reconstruct, _list_children
-from .metadata import ProjectMetadata, ExperimentMetadata
+from .asset import AssetLibrary
+from .base import _list_children, _load_metadata, _reconstruct, _save_metadata
 from .experiment import Experiment
+from .models import ExperimentMetadata, ProjectMetadata
 from .utils import slugify
 
 
 class Project:
-    """Research project container with runtime behavior.
-    
-    Construction is side-effect free and auto-generates metadata.
-    Filesystem operations happen explicitly via materialize().
-    
-    Example:
-        >>> # User provides only what they care about
-        >>> project = Project(
-        ...     name="QM9 Energy Prediction",
-        ...     workspace=workspace
-        ... )
-        >>> 
-        >>> # System fields auto-generated
-        >>> assert project.id  # Slugified from name
-        >>> assert project.metadata.created_at  # Timestamp auto-generated
-        >>> 
-        >>> # No filesystem side effects yet
-        >>> # Explicitly materialize to disk
-        >>> project.materialize()  # NOW directories/files are created
+    """Research project container.
+
+    Example::
+
+        ws = Workspace("./lab")
+        project = ws.project("QM9")
+        exp = project.experiment("baseline", params={"lr": 1e-3})
     """
-    
-    def __init__(
-        self,
-        name: str,
-        workspace: Workspace,
-    ):
-        """Initialize project with user inputs and auto-generate metadata.
-        
-        Args:
-            name: Human-readable project name (user input)
-            workspace: Root workspace (runtime dependency)
-        """
+
+    def __init__(self, name: str, workspace: Workspace) -> None:
         self.workspace = workspace
-        
-        # Auto-generate metadata with system fields
-        self.metadata = ProjectMetadata(
-            id=slugify(name),  # Auto-generated from name
-            name=name,
-            created_at=datetime.now(),  # Auto-generated timestamp
-            updated_at=datetime.now(),
-            description="",
-            owner="",
-            tags=[],
-            config={}
-        )
-        
-        # Runtime-only cache
-        self._assets_lib = None
-    
-    # Property proxies for convenient access to metadata fields
-    
+        self.metadata = ProjectMetadata(id=slugify(name), name=name)
+        self._assets_lib: AssetLibrary | None = None
+        self._experiments_cache: dict[str, Experiment] = {}
+
+    # ── Properties ──────────────────────────────────────────────────────
+
     @property
     def id(self) -> str:
-        """Project identifier."""
         return self.metadata.id
-    
+
     @property
     def name(self) -> str:
-        """Human-readable project name."""
         return self.metadata.name
-    
+
     @property
     def created_at(self):
-        """Creation timestamp."""
         return self.metadata.created_at
-    
-    @property
-    def updated_at(self):
-        """Last update timestamp."""
-        return self.metadata.updated_at
-    
+
     @property
     def description(self) -> str:
-        """Project description."""
         return self.metadata.description
 
     @property
     def owner(self) -> str:
-        """Project owner."""
         return self.metadata.owner
 
     @property
     def tags(self) -> list[str]:
-        """Project tags."""
         return self.metadata.tags
 
     @property
     def config(self) -> dict[str, Any]:
-        """Project configuration."""
         return self.metadata.config
-    
-    @property
-    def description(self) -> str:
-        """Project description."""
-        return self.metadata.description
 
     @property
-    def owner(self) -> str:
-        """Project owner."""
-        return self.metadata.owner
-
-    @property
-    def tags(self) -> list[str]:
-        """Project tags."""
-        return self.metadata.tags
+    def project_dir(self) -> Path:
+        return self.workspace.root / "projects" / self.id
 
     @property
-    def config(self) -> dict[str, Any]:
-        """Project configuration."""
-        return self.metadata.config
-    
-    @property
-    def assets(self):
-        """Project-level asset library."""
-        from .asset import AssetLibrary
-
-        assets_dir = self.workspace.root / "projects" / self.id / "assets"
+    def assets(self) -> AssetLibrary:
         if self._assets_lib is None:
-            self._assets_lib = AssetLibrary(assets_dir)
+            self._assets_lib = AssetLibrary(self.project_dir / "assets")
         return self._assets_lib
 
-    def import_asset(self, name: str, src: str | Path, action: str = "copy", meta: dict[str, Any] | None = None):
-        """Import asset and update project metadata.
-
-        Args:
-            name: Asset name
-            src: Source path
-            action: Import action ("copy", "move", "symlink", "hardlink")
-            meta: Optional metadata
-
-        Returns:
-            Asset object
-        """
-        asset = self.assets.import_asset(name, src, action, meta)
-
-        # Register asset in project metadata
-        if name not in self.metadata.assets:
-            self.metadata.assets.append(name)
-            self.save()
-
-        return asset
-
-    def create_asset(self, name: str, meta: dict[str, Any] | None = None):
-        """Create a new empty asset and update project metadata.
-
-        Args:
-            name: Asset name
-            meta: Optional metadata
-
-        Returns:
-            Asset object with empty payload directory
-        """
-        from .asset import Asset
-        from .utils import generate_asset_id
-        from datetime import datetime
-        import json
-
-        # Check if asset already exists
-        existing_asset = self.assets.get_asset(name)
-        if existing_asset:
-            return existing_asset
-
-        # Generate asset ID and create directory structure
-        asset_id = generate_asset_id()
-        created_at = datetime.now()
-
-        asset_dir = self.assets.root / asset_id
-        asset_dir.mkdir(parents=True, exist_ok=True)
-        payload_dir = asset_dir / "payload"
-        payload_dir.mkdir(exist_ok=True)
-
-        # Prepare metadata
-        metadata = meta.copy() if meta else {}
-
-        # Create asset object
-        asset = Asset(
-            asset_id=asset_id,
-            name=name,
-            library_root=self.assets.root,
-            created_at=created_at,
-            metadata=metadata,
-        )
-
-        # Save asset metadata
-        metadata_file = asset_dir / "asset.json"
-        with open(metadata_file, 'w') as f:
-            json.dump({
-                "asset_id": asset_id,
-                "name": name,
-                "created_at": created_at.isoformat(),
-                "metadata": metadata,
-            }, f, indent=2)
-
-        # Update index
-        self.assets._index[name] = asset_id
-        self.assets._save_index()
-
-        # Register asset in project metadata
-        if name not in self.metadata.assets:
-            self.metadata.assets.append(name)
-            self.save()
-
-        return asset
+    # ── Persistence ─────────────────────────────────────────────────────
 
     def materialize(self) -> None:
-        """Create filesystem structure and persist metadata.
+        """Create filesystem structure and persist metadata (non-recursive)."""
+        self.project_dir.mkdir(parents=True, exist_ok=True)
+        _save_metadata(self.metadata, self.project_dir / "project.json")
 
-        This is the explicit side-effect method that:
-        - Creates project directory
-        - Writes metadata JSON file
-        - Initializes subdirectories (assets, experiments)
-        """
-        project_dir = self.workspace.root / "projects" / self.id
-        project_dir.mkdir(parents=True, exist_ok=True)
-        _save_metadata(self.metadata, project_dir / "project.json")
-    
     def save(self) -> None:
-        """Save updated metadata to disk."""
-        project_dir = self.workspace.root / "projects" / self.id
-        self.metadata.updated_at = datetime.now()
-        _save_metadata(self.metadata, project_dir / "project.json")
-    
-    def create_experiment(self, name: str, id: str | None = None, exist_ok: bool = False) -> Experiment:
-        """Create experiment in this project.
+        """Persist current metadata to disk."""
+        _save_metadata(self.metadata, self.project_dir / "project.json")
 
-        Args:
-            name: Experiment name (user input)
-            id: Optional custom ID (if None, auto-generates UUID)
-            exist_ok: If True, return existing experiment if found by name (when id=None)
-                     or by id (when id is provided)
+    def import_asset(
+        self,
+        name: str,
+        src: str | Path,
+        action: str = "copy",
+        meta: dict[str, Any] | None = None,
+    ):
+        """Import an asset into the project library."""
+        return self.assets.import_asset(name, src, action, meta)
 
-        Returns:
-            Created Experiment (already materialized)
+    # ── Experiment operations ───────────────────────────────────────────
 
-        Raises:
-            ValueError: If experiment with this ID already exists and exist_ok=False
+    def experiment(
+        self,
+        name: str,
+        *,
+        id: str | None = None,
+        params: dict[str, Any] | None = None,
+        n_replicas: int = 1,
+        seeds: list[int] | None = None,
+        workflow_source: str | None = None,
+        workflow_type: str | None = None,
+        git_commit: str | None = None,
+    ) -> Experiment:
+        """Get-or-create an experiment (idempotent, materialized immediately).
+
+        If an experiment with the same ID (or slug from *name*) exists on
+        disk, it is loaded and returned.  Otherwise a new experiment is
+        constructed and materialized.
         """
-        # If exist_ok=True and no custom id, try to find existing experiment by name
-        if exist_ok and id is None:
-            experiments_dir = self.workspace.root / "projects" / self.id / "experiments"
-            if experiments_dir.exists():
-                from .base import _load_metadata, _reconstruct
-                from .metadata import ExperimentMetadata
-
-                for exp_dir in experiments_dir.iterdir():
-                    if exp_dir.is_dir():
-                        metadata_file = exp_dir / "experiment.json"
-                        if metadata_file.exists():
-                            metadata = _load_metadata(ExperimentMetadata, metadata_file)
-                            if metadata.name == name:
-                                # Found existing experiment with same name
-                                attrs = {
-                                    'metadata': metadata,
-                                    'project': self,
-                                    '_assets_lib': None,
-                                }
-                                return _reconstruct(Experiment, attrs)
-
-        # Construct experiment (no side effects)
-        experiment = Experiment(
-            name=name,
-            project=self,
-            id=id,
-        )
-
-        # Check if experiment already exists by ID
-        experiment_dir = self.workspace.root / "projects" / self.id / "experiments" / experiment.id
-        if experiment_dir.exists():
-            if exist_ok:
-                # Load existing experiment
-                metadata_file = experiment_dir / "experiment.json"
-                if metadata_file.exists():
-                    from .base import _load_metadata, _reconstruct
-                    from .metadata import ExperimentMetadata
-                    metadata = _load_metadata(ExperimentMetadata, metadata_file)
-                    attrs = {
-                        'metadata': metadata,
-                        'project': self,
-                        '_assets_lib': None,
-                    }
-                    return _reconstruct(Experiment, attrs)
-            raise ValueError(f"Experiment '{experiment.id}' already exists")
-
-        # Explicitly materialize
-        experiment.materialize()
-
-        # Register experiment in project metadata
-        if experiment.id not in self.metadata.experiments:
-            self.metadata.experiments.append(experiment.id)
-            self.save()
+        exp_id = id if id is not None else slugify(name)
+        if exp_id in self._experiments_cache:
+            return self._experiments_cache[exp_id]
+        exp_dir = self.project_dir / "experiments" / exp_id
+        if exp_dir.exists():
+            exp = self._load_experiment_from_dir(exp_dir)
+        else:
+            exp = Experiment(
+                name=name,
+                project=self,
+                id=exp_id,
+                params=params,
+                n_replicas=n_replicas,
+                seeds=seeds,
+                workflow_source=workflow_source,
+                workflow_type=workflow_type,
+                git_commit=git_commit,
+            )
+            exp.materialize()
+        self._experiments_cache[exp.id] = exp
+        return exp
 
-        return experiment
-    
     def get_experiment(self, experiment_id: str) -> Experiment | None:
-        """Get experiment by ID (load from disk).
-
-        Args:
-            experiment_id: Experiment UUID
-
-        Returns:
-            Experiment object if found, None otherwise
-        """
-        experiment_dir = (
-            self.workspace.root / "projects" / self.id / "experiments" / experiment_id
-        )
-
-        if not experiment_dir.exists():
+        """Get experiment by ID."""
+        if experiment_id in self._experiments_cache:
+            return self._experiments_cache[experiment_id]
+        exp_dir = self.project_dir / "experiments" / experiment_id
+        if not exp_dir.exists():
             return None
+        exp = self._load_experiment_from_dir(exp_dir)
+        self._experiments_cache[exp.id] = exp
+        return exp
 
-        metadata = _load_metadata(ExperimentMetadata, experiment_dir / "experiment.json")
-        return _reconstruct(Experiment, {
-            "project": self,
-            "metadata": metadata,
-            "_assets_lib": None,
-        })
-    
     def list_experiments(self) -> list[Experiment]:
-        """List experiments in this project.
-
-        Returns:
-            List of Experiment objects
-        """
-        return _list_children(
-            children_dir=self.workspace.root / "projects" / self.id / "experiments",
+        """List all experiments (disk scan merged with in-memory cache)."""
+        seen: dict[str, Experiment] = dict(self._experiments_cache)
+        scanned = _list_children(
+            children_dir=self.project_dir / "experiments",
             metadata_filename="experiment.json",
             metadata_cls=ExperimentMetadata,
             child_cls=Experiment,
-            attrs_factory=lambda m: {"project": self, "metadata": m, "_assets_lib": None},
+            attrs_factory=lambda m: {
+                "project": self,
+                "metadata": m,
+                "_assets_lib": None,
+                "_workflow": None,
+            },
+        )
+        for e in scanned:
+            seen.setdefault(e.id, e)
+        return list(seen.values())
+
+    # ── Internal ────────────────────────────────────────────────────────
+
+    def _load_experiment_from_dir(self, exp_dir: Path) -> Experiment:
+        meta = _load_metadata(ExperimentMetadata, exp_dir / "experiment.json")
+        return _reconstruct(
+            Experiment,
+            {
+                "project": self,
+                "metadata": meta,
+                "_assets_lib": None,
+                "_workflow": None,
+            },
         )
diff --git a/src/molexp/workspace/resume_policy.py b/src/molexp/workspace/resume_policy.py
index 8ebf5382..7add391f 100644
--- a/src/molexp/workspace/resume_policy.py
+++ b/src/molexp/workspace/resume_policy.py
@@ -6,11 +6,13 @@
 
 from __future__ import annotations
 
-from typing import Protocol, TYPE_CHECKING
+from typing import TYPE_CHECKING, Protocol
+
+from .run import RunStatus
 
 if TYPE_CHECKING:
     from .checkpoint import CheckpointState
-    from .run import Run, RunStatus
+    from .run import Run
 
 
 class ResumePolicy(Protocol):
@@ -83,8 +85,6 @@ def should_resume(
         checkpoint: CheckpointState
     ) -> bool:
         """Resume if run status is FAILED or CANCELLED."""
-        from .run import RunStatus
-        
         return run.status in [RunStatus.FAILED, RunStatus.CANCELLED]
 
 
diff --git a/src/molexp/workspace/run.py b/src/molexp/workspace/run.py
index 65e8ea9d..117c7824 100644
--- a/src/molexp/workspace/run.py
+++ b/src/molexp/workspace/run.py
@@ -1,746 +1,536 @@
-"""Run entity and execution context with actor message passing support.
+"""Run entity and RunContext execution lifecycle.
 
-This module provides the Run and RunContext classes for workflow execution:
-
-1. **Run**: Represents a single execution instance within an experiment. Tracks
-   parameters, metadata, and execution state. Persisted via materialize().
-
-2. **RunContext**: Primary execution context interface for tasks and actors. Provides:
-   - Lifecycle management (__enter__/__exit__)
-   - Result binding (set_result/get_result)
-   - Checkpoint creation
-   - **Message passing**: emit() and receive() for actor communication
-   - **Channel management**: Dynamic channel registration and monitoring
-
-Message Passing (Hybrid Mode):
-    For workflows containing Actors, RunContext provides async message passing:
-    - `await ctx.receive(channel)`: Receive message from named channel (blocks if empty)
-    - `await ctx.emit(channel, msg)`: Send message to named channel (backpressure support)
-    - `ctx.get_channel_depths()`: Monitor channel queue sizes
-
-Example:
-    Batch task execution::
-
-        with run.start() as ctx:
-            result = task.execute(ctx=ctx, input_value=42)
-            ctx.set_result('task_id', result)
-
-    Actor message passing::
-
-        async def execute(self, ctx, **inputs):
-            data = await ctx.receive('input_channel')
-            result = self.process(data)
-            await ctx.emit('output_channel', result)
-            yield
+A **Run** represents a single execution instance within an experiment.
+**RunContext** is the context manager that handles lifecycle, artifacts,
+checkpoints, and asset access during execution.
 """
 
 from __future__ import annotations
 
 import json
+import os
+import platform
+import time
 import traceback
 from datetime import datetime
+from enum import Enum
 from pathlib import Path
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
+from mollog import get_logger
 from pydantic import BaseModel
 
 if TYPE_CHECKING:
     from .experiment import Experiment
 
-from .base import _save_metadata, _load_metadata, _reconstruct
+from molexp.config import ProfileConfig
+
+from .base import _atomic_write_json, _load_metadata, _reconstruct, _save_metadata
 from .context import Context
-from .metadata import RunMetadata, ExperimentMetadata, ProjectMetadata, WorkspaceMetadata
+from .models import ErrorInfo, ExecutionRecord, RunMetadata, WorkflowSnapshotRef
 from .utils import generate_id
 
-from molexp.workflow.status import TaskStatus as RunStatus
+logger = get_logger(__name__)
+
+
+class RunStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+# ── RunContext ──────────────────────────────────────────────────────────────
 
 
 class RunContext:
-    """Primary execution context interface.
-    
-    Encapsulates:
-    - Pure Context data model (internal)
-    - Lifecycle management (__enter__/__exit__)
-    - Result binding methods
-    - Checkpoint creation
-    - Context serialization
-    
-    Users interact with RunContext, not Context directly.
-    
-    Attributes:
-        run: The Run being executed (can be None for standalone mode)
-        work_dir: Run working directory
-        artifacts_dir: Directory for artifacts
-        _context: Internal Context data model
+    """Primary execution context.
+
+    Entered via ``with run.start() as ctx:`` — manages lifecycle,
+    result binding, checkpointing, artifact storage, and asset access.
+
+    The active :class:`~molexp.config.ProfileConfig` is fixed at
+    construction time via ``profile_config``.  Late-binding after
+    construction is not permitted.
     """
-    
-    def __init__(self, run: Run):
+
+    def __init__(
+        self,
+        run: Run,
+        *,
+        profile_config: ProfileConfig | None = None,
+    ) -> None:
         self.run = run
-        
-        # Compute work_dir from hierarchy
-        self.work_dir = (
-            self.run.experiment.project.workspace.root / "projects" /
-            self.run.experiment.project.id / "experiments" /
-            self.run.experiment.id / "runs" / self.run.id
-        )
-        
-        # Artifacts directory
+        self.work_dir = run.run_dir
         self.artifacts_dir = self.work_dir / "artifacts"
-        
-        # Internal: Pure Context BaseModel
+        self.logs_dir = self.work_dir / "logs"
+        self._profile_config = (
+            profile_config if profile_config is not None else ProfileConfig({}, name=None)
+        )
+        self._entered = False
         self._context = Context(
-            run_id=self.run.id,
-            experiment_id=self.run.experiment.id,
-            project_id=self.run.experiment.project.id,
+            run_id=run.id,
+            experiment_id=run.experiment.id,
+            project_id=run.experiment.project.id,
             work_dir=self.work_dir,
             artifacts_dir=self.artifacts_dir,
+            logs_dir=self.logs_dir,
         )
-        
-        # Runtime state
-        self._start_time = None
-
-        # Actor message passing infrastructure
-        self._channels: dict[str, Any] = {}  # channel_name -> asyncio.Queue
-        self._channel_routing: dict[tuple[str, str], str] = {}  # (actor_id, channel_name) -> target_channel
-    
-    # ========== Lifecycle ==========
-    
-    def __enter__(self) -> "RunContext":
-        """Initialize execution and save initial state."""
-        # Create directory structure
+        self._start_time: datetime | None = None
+        self._execution_id: str | None = None
+        # Actor message-passing infrastructure
+        self._channels: dict[str, Any] = {}
+
+    # ── Lifecycle ───────────────────────────────────────────────────────
+
+    def __enter__(self) -> RunContext:
         self.work_dir.mkdir(parents=True, exist_ok=True)
         self.artifacts_dir.mkdir(exist_ok=True)
-
-        # Load existing results from previous phases before overwriting
+        self.logs_dir.mkdir(exist_ok=True)
         self._load_existing_results()
-
-        # Set status to running
-        self.run.status = RunStatus.RUNNING
+        self._apply_profile_metadata()
+        self._claim_ownership()
+        self.run._set_status(RunStatus.RUNNING)
         self._start_time = datetime.now()
+        self._entered = True
+
+        # Determine which execution attempt this is and record it.
+        self._execution_id = self._next_execution_id()
+        new_record = ExecutionRecord(
+            execution_id=self._execution_id,
+            started_at=self._start_time,
+        )
+        self.run._update_metadata(
+            execution_history=[*self.run.metadata.execution_history, new_record]
+        )
+        self._append_run_log(
+            f"execution started  exec_id={self._execution_id}"
+        )
 
-        # Serialize initial context to run.json
         self._save_context()
+        return self
 
-        return self  # Return RunContext, not Context
-    
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """Finalize execution and save final state.
-        
-        Status is determined by:
-        1. Python exceptions (exc_type is not None)
-        2. Workflow execution status (self._context.status)
-        
-        This ensures that workflow-level failures (task failures, cancellations)
-        are properly reflected in the Run status, even when no exception is raised.
-        """
+        now = datetime.now()
+        labels = self._labels_without_ownership()
         if exc_type is None:
-            # No Python exception, check workflow execution status
-            workflow_status = self._context.status.get('run')
-            if workflow_status == RunStatus.FAILED:
-                # Workflow failed (tasks failed or were cancelled)
-                self.run.status = RunStatus.FAILED
-                self.run.metadata.finished_at = datetime.now()
-            else:
-                # Success
-                self.run.status = RunStatus.SUCCEEDED
-                self.run.metadata.finished_at = datetime.now()
+            workflow_status = self._context.status.get("run")
+            final = RunStatus.FAILED if workflow_status == RunStatus.FAILED else RunStatus.SUCCEEDED
+            self.run._update_metadata(
+                status=final, finished_at=now, labels=labels,
+                execution_history=self._close_execution_record(final.value, now),
+            )
         else:
-            # Python exception occurred
-            self.run.status = RunStatus.FAILED
-            self.run.metadata.finished_at = datetime.now()
-            
-            # Save error summary to metadata
-            self.run.metadata.error = {
-                "type": exc_type.__name__,
-                "message": str(exc_val),
-                "timestamp": datetime.now().isoformat(),
-            }
-            
-            # Save full traceback to error files
+            final = RunStatus.FAILED
+            self.run._update_metadata(
+                status=final,
+                finished_at=now,
+                labels=labels,
+                error=ErrorInfo(
+                    type=exc_type.__name__,
+                    message=str(exc_val),
+                    timestamp=now,
+                ),
+                execution_history=self._close_execution_record(final.value, now),
+            )
             self._save_error_details(exc_type, exc_val, exc_tb)
-        
-        # Serialize final context to run.json
+        self._append_run_log(
+            f"execution finished exec_id={self._execution_id}  status={final.value}"
+        )
         self._save_context()
-        
-        return False  # Don't suppress exceptions
-    
-    # ========== Public API ==========
-    
-    def set_result(self, key: str, value: Any) -> None:
-        """Bind a result to the context.
-        
+        self._entered = False
+        return False
+
+    # ── Public API ──────────────────────────────────────────────────────
+
+    @property
+    def params(self) -> dict[str, Any]:
+        """Shortcut for ``self.run.parameters``."""
+        return self.run.parameters
+
+    @property
+    def config(self) -> ProfileConfig:
+        """Active profile configuration (read-only mapping)."""
+        return self._profile_config
+
+    def get_data_dir(
+        self,
+        asset_name: str,
+        *,
+        fallback: str | Path | None = None,
+    ) -> Path:
+        """Resolve a data directory path.
+
+        Searches the asset hierarchy first. If no asset is found and
+        *fallback* is given, creates ``workspace_root / fallback`` and
+        returns it.  All return values are :class:`~pathlib.Path`.
+
         Args:
-            key: Result key
-            value: Result value (will be serialized)
+            asset_name: Name of the asset to look up.
+            fallback: Relative path under workspace root to create when the
+                asset is not found.
+
+        Returns:
+            Resolved data directory path.
+
+        Raises:
+            FileNotFoundError: If no asset found and no fallback specified.
         """
+        asset = self.find_asset(asset_name)
+        if asset is not None:
+            return Path(asset.path)
+        if fallback is not None:
+            fallback = Path(fallback)
+            data_dir = self.run.experiment.project.workspace.root / fallback
+            data_dir.mkdir(parents=True, exist_ok=True)
+            return data_dir
+        raise FileNotFoundError(
+            f"Asset {asset_name!r} not found and no fallback specified."
+        )
+
+    def set_result(self, key: str, value: Any) -> None:
         self._context.results[key] = value
-    
+
     def get_result(self, key: str) -> Any:
-        """Get a result from the context.
-        
-        Args:
-            key: Result key
-            
-        Returns:
-            Result value or None if not found
-        """
         return self._context.results.get(key)
-    
-    def set_workflow(self, workflow: BaseModel | dict) -> None:
-        """Set workflow data in context.
 
-        Args:
-            workflow: Workflow object (Pydantic model or dict)
-        """
+    def set_workflow(self, workflow: BaseModel | dict) -> None:
         if isinstance(workflow, BaseModel):
-            self._context.workflow = workflow.model_dump(exclude={"_tasks"})
+            self._context.workflow = workflow.model_dump()
         elif isinstance(workflow, dict):
             self._context.workflow = workflow
         else:
-            raise TypeError("Workflow must be Pydantic BaseModel or dict")
-    
+            raise TypeError("workflow must be a Pydantic BaseModel or dict")
+
     def checkpoint(self, name: str | None = None) -> str:
-        """Create checkpoint of current context state.
-        
-        Args:
-            name: Optional checkpoint name
-            
-        Returns:
-            Checkpoint ID
-        """
         from .checkpoint import generate_checkpoint_id
-        
+
         ckpt_id = generate_checkpoint_id()
         ckpt_dir = self.work_dir / ".ckpt"
         ckpt_dir.mkdir(exist_ok=True)
-        
-        ckpt_file = ckpt_dir / f"{ckpt_id}.json"
-        with open(ckpt_file, 'w') as f:
-            json.dump({
-                "ckpt_id": ckpt_id,
-                "name": name,
-                "timestamp": datetime.now().isoformat(),
-                "context": self._context.model_dump(mode='json')
-            }, f, indent=2, default=str)
-        
+        _atomic_write_json(ckpt_dir / f"{ckpt_id}.json", {
+            "ckpt_id": ckpt_id,
+            "name": name,
+            "timestamp": datetime.now().isoformat(),
+            "context": self._context.model_dump(mode="json"),
+        })
         return ckpt_id
-    
+
     def save_artifact(self, name: str, data: Any) -> Path:
-        """Save an artifact to the artifacts directory.
-        
-        Args:
-            name: Artifact filename
-            data: Data to save (dict will be saved as JSON)
-            
-        Returns:
-            Path to saved artifact
-        """
         artifact_path = self.artifacts_dir / name
-        
         if isinstance(data, dict):
-            with open(artifact_path, 'w') as f:
+            with open(artifact_path, "w") as f:
                 json.dump(data, f, indent=2, default=str)
+        elif isinstance(data, (bytes, bytearray)):
+            with open(artifact_path, "wb") as f:
+                f.write(data)
+        elif isinstance(data, Path):
+            import shutil
+            shutil.copy2(data, artifact_path)
         else:
-            # Handle other types as text
-            with open(artifact_path, 'w') as f:
+            with open(artifact_path, "w") as f:
                 f.write(str(data))
-        
         return artifact_path
-    
-    # ========== Internal Methods ==========
-
-    def _load_existing_results(self):
-        """Load results from an existing run.json into the context.
-
-        This enables cross-phase workflows where phase 2 needs outputs
-        produced by phase 1. Called during __enter__ before the initial
-        save overwrites run.json.
-        """
-        run_json = self.work_dir / "run.json"
-        if not run_json.exists() or run_json.stat().st_size == 0:
-            return
-
-        with open(run_json, "r") as f:
-            data = json.load(f)
-        persisted = data.get("context", {}).get("results", {})
-        for key, value in persisted.items():
-            if key not in self._context.results:
-                self._context.results[key] = value
 
-    def _save_context(self):
-        """Serialize context to run.json."""
-        run_json = self.work_dir / "run.json"
-        context_dict = self._context.model_dump(mode='json')
-
-        with open(run_json, 'w') as f:
-            json.dump({
-                "id": self.run.id,
-                "status": self.run.status,
-                "parameters": self.run.parameters,
-                "assets": self.run.assets,
-                "created_at": self.run.metadata.created_at.isoformat(),
-                "updated_at": datetime.now().isoformat(),
-                "context": context_dict
-            }, f, indent=2, default=str)
-    
-    def _save_error_details(self, exc_type, exc_val, exc_tb):
-        """Save detailed error information to files."""
-        # Format traceback
-        tb_lines = traceback.format_exception(exc_type, exc_val, exc_tb)
-        tb_text = ''.join(tb_lines)
-        
-        # Save as text in artifacts
-        error_txt = self.artifacts_dir / "error.txt"
-        with open(error_txt, 'w') as f:
-            f.write(f"Error occurred at: {datetime.now().isoformat()}\n")
-            f.write(f"Exception type: {exc_type.__name__}\n")
-            f.write(f"Exception message: {str(exc_val)}\n\n")
-            f.write("Traceback:\n")
-            f.write(tb_text)
-        
-        # Save as JSON in artifacts
-        error_json = self.artifacts_dir / "error.json"
-        error_data = {
-            "timestamp": datetime.now().isoformat(),
-            "type": exc_type.__name__,
-            "message": str(exc_val),
-            "traceback": tb_lines,
-        }
-        with open(error_json, 'w') as f:
-            json.dump(error_data, f, indent=2)
-    
-    # ========== Internal Access (for Engine) ==========
-    
-    @property
-    def context(self) -> Context:
-        """Access internal Context (for engine use only).
-
-        Note: Prefer using RunContext methods over direct context access.
-        """
-        return self._context
+    def get_artifact_path(self, name: str) -> Path:
+        return self.artifacts_dir / name
 
-    # ========== Asset Registration ==========
+    # ── Asset access ────────────────────────────────────────────────────
 
     def register_asset(
         self,
         name: str,
         src: Path | str,
         action: str = "copy",
-        meta: dict | None = None
+        meta: dict | None = None,
     ):
-        """Register an asset at experiment level.
-        
-        Assets are important outputs that may be reused by other runs.
-        
-        Args:
-            name: Asset name
-            src: Source path
-            action: Import action (copy, move, symlink, hardlink)
-            meta: Optional metadata
-            
-        Returns:
-            Created Asset
-        """
-        asset = self.run.experiment.assets.import_asset(
-            name=name,
-            src=src,
-            action=action,
-            meta=meta or {}
+        return self.run.experiment.assets.import_asset(
+            name=name, src=src, action=action, meta=meta or {}
         )
-        
-        # Track reference in run.assets
-        if "assets" not in self.run.assets:
-            self.run.assets["assets"] = {}
-        self.run.assets["assets"][name] = asset.id
-        self.run.save()
-        
-        return asset
-    
-    def get_asset(self, name: str, scope: str = "project"):
-        """Get an asset by name from a specific scope.
-
-        Args:
-            name: Asset name to look up
-            scope: Scope to search in ('experiment', 'project', or 'workspace')
-
-        Returns:
-            Asset object if found, None otherwise
-
-        Raises:
-            ValueError: If scope is not recognized
-        """
-        from .asset import AssetLibrary
 
+    def get_asset(self, name: str, scope: str = "project"):
         if scope == "experiment":
             return self.run.experiment.assets.get_asset(name)
         elif scope == "project":
             return self.run.experiment.project.assets.get_asset(name)
         elif scope == "workspace":
             return self.run.experiment.project.workspace.assets.get_asset(name)
-        else:
-            raise ValueError(
-                f"Unknown scope: {scope!r}. Use 'experiment', 'project', or 'workspace'."
-            )
+        raise ValueError(f"Unknown scope: {scope!r}")
 
     def find_asset(self, name: str):
-        """Find an asset by name, searching upward through scopes.
-
-        Search order: experiment → project → workspace.
-        Returns the first match found.
-
-        Args:
-            name: Asset name to look up
-
-        Returns:
-            Asset object if found, None otherwise
-        """
         for scope in ("experiment", "project", "workspace"):
             asset = self.get_asset(name, scope=scope)
             if asset is not None:
                 return asset
         return None
 
-    def get_artifact_path(self, name: str) -> Path:
-        """Get path to an artifact."""
-        return self.artifacts_dir / name
-
-    # ========== Actor Message Passing API ==========
+    # ── Actor message passing ───────────────────────────────────────────
 
     async def receive(self, channel: str) -> Any:
-        """Receive one message from named channel (for Actors).
-
-        Blocks if channel is empty until a message arrives.
-        Channel names are dynamic and routed by workflow Links.
-
-        Args:
-            channel: Channel name to receive from
-
-        Returns:
-            Message from the channel
-
-        Raises:
-            KeyError: If channel does not exist (not connected in workflow)
-
-        Example:
-            >>> async def execute(self, ctx, **inputs):
-            ...     data = await ctx.receive('data')
-            ...     result = self.process(data)
-            ...     await ctx.emit('results', result)
-        """
         if channel not in self._channels:
-            raise KeyError(
-                f"Channel '{channel}' not found. Available channels: {list(self._channels.keys())}"
-            )
-
-        queue = self._channels[channel]
-        return await queue.get()
+            raise KeyError(f"Channel '{channel}' not found")
+        return await self._channels[channel].get()
 
     async def emit(self, channel: str, message: Any) -> None:
-        """Send message to named channel (for Actors).
-
-        Blocks if channel is full until space is available (backpressure).
-        Channel names are dynamic and routed by workflow Links.
-
-        If channel doesn't exist (no consumer connected), message is silently dropped.
-
-        Args:
-            channel: Channel name to send to
-            message: Message to send
-
-        Example:
-            >>> async def execute(self, ctx, **inputs):
-            ...     data = await ctx.receive('data')
-            ...     result = self.process(data)
-            ...     await ctx.emit('results', result)
-        """
         if channel not in self._channels:
-            # Channel not connected - drop message silently
-            # This allows actors to produce output without requiring consumers
+            logger.warning(f"emit() to non-existent channel {channel!r} — dropped")
             return
+        await self._channels[channel].put(message)
 
-        queue = self._channels[channel]
-        await queue.put(message)
-
-    def get_channel_depths(self) -> dict[str, int]:
-        """Get current depth (qsize) of all channels.
-
-        Useful for monitoring backpressure and debugging.
-
-        Returns:
-            Dict mapping channel names to current queue sizes
-
-        Example:
-            >>> depths = ctx.get_channel_depths()
-            >>> print(depths)  # {'data': 45, 'results': 12}
-        """
-        return {
-            name: queue.qsize()
-            for name, queue in self._channels.items()
-        }
-
-    def _register_channel(self, name: str, queue: Any) -> None:
-        """Register a channel (for engine use only).
-
-        Args:
-            name: Channel name
-            queue: asyncio.Queue instance
-        """
-        self._channels[name] = queue
+    # ── Constructor helpers ─────────────────────────────────────────────
 
     @classmethod
-    def from_run_dir(cls, path: Path) -> RunContext:
+    def open(cls, run_dir: Path) -> RunContext:
         """Reconstruct a RunContext from an existing run directory.
 
-        Reads run.json and rebuilds the full Workspace → Project → Experiment → Run
-        hierarchy by walking the filesystem upward. Parent entities are reconstructed
-        lazily using metadata files found on disk.
+        Traverses the directory hierarchy to rebuild the full
+        Workspace → Project → Experiment → Run chain.
 
         Args:
-            path: Path to the run directory (must contain run.json)
+            run_dir: Path to the run directory (contains ``run.json``).
 
         Returns:
-            RunContext with restored hierarchy and context data
+            ``RunContext`` wrapping the reconstructed run.
 
         Raises:
-            FileNotFoundError: If run.json or parent metadata files are missing
+            FileNotFoundError: If workspace, project, experiment or run metadata is missing.
         """
-        path = Path(path).resolve()
-        run_json_path = path / "run.json"
-        if not run_json_path.exists():
-            raise FileNotFoundError(f"run.json not found in {path}")
-
-        # Read run.json (RunContext format: {id, status, parameters, assets, context: {...}})
-        with open(run_json_path, "r") as f:
-            run_data = json.load(f)
-
-        # Walk directory hierarchy upward:
-        # run_dir / .. = runs/ / .. = experiment_dir / .. = experiments/ / .. = project_dir / .. = projects/ / .. = workspace_root
-        run_dir = path
-        runs_dir = run_dir.parent          # .../runs/
-        experiment_dir = runs_dir.parent    # .../experiments/{experiment_id}/
-        experiments_dir = experiment_dir.parent  # .../experiments/
-        project_dir = experiments_dir.parent     # .../projects/{project_id}/
-        projects_dir = project_dir.parent        # .../projects/
-        workspace_root = projects_dir.parent     # workspace root
-
-        # Reconstruct Workspace
         from .workspace import Workspace
-        ws_meta_path = workspace_root / "workspace.json"
-        if not ws_meta_path.exists():
-            raise FileNotFoundError(
-                f"workspace.json not found at {ws_meta_path}. "
-                f"Cannot reconstruct workspace hierarchy from {path}"
-            )
-        ws_meta = _load_metadata(WorkspaceMetadata, ws_meta_path)
-        workspace = _reconstruct(Workspace, {
-            "root": workspace_root,
-            "metadata": ws_meta,
-            "_assets_lib": None,
-        })
 
-        # Reconstruct Project
-        from .project import Project
-        proj_meta_path = project_dir / "project.json"
-        if not proj_meta_path.exists():
+        run_dir = Path(run_dir).resolve()
+        # Layout: workspace_root/projects/proj_id/experiments/exp_id/runs/run-{id}
+        workspace_root = run_dir.parents[5]
+        project_id = run_dir.parents[3].name
+        experiment_id = run_dir.parents[1].name
+
+        workspace = Workspace.load(workspace_root)
+        project = workspace.get_project(project_id)
+        if project is None:
             raise FileNotFoundError(
-                f"project.json not found at {proj_meta_path}. "
-                f"Cannot reconstruct project from {path}"
+                f"Project '{project_id}' not found in workspace at {workspace_root}"
             )
-        proj_meta = _load_metadata(ProjectMetadata, proj_meta_path)
-        project = _reconstruct(Project, {
-            "workspace": workspace,
-            "metadata": proj_meta,
-            "_assets_lib": None,
-        })
-
-        # Reconstruct Experiment
-        from .experiment import Experiment
-        exp_meta_path = experiment_dir / "experiment.json"
-        if not exp_meta_path.exists():
+        experiment = project.get_experiment(experiment_id)
+        if experiment is None:
             raise FileNotFoundError(
-                f"experiment.json not found at {exp_meta_path}. "
-                f"Cannot reconstruct experiment from {path}"
+                f"Experiment '{experiment_id}' not found in project '{project_id}'"
             )
-        exp_meta = _load_metadata(ExperimentMetadata, exp_meta_path)
-        experiment = _reconstruct(Experiment, {
-            "project": project,
-            "metadata": exp_meta,
-            "_assets_lib": None,
-        })
+        # Load run metadata directly from run_dir/run.json.
+        # Avoid experiment.get_run() which calls run_dir.exists() — on Lustre/NFS
+        # filesystems that call can return False for newly-created directories due
+        # to metadata cache staleness on compute nodes, even when the directory and
+        # file are physically present.
+        run_json = run_dir / "run.json"
+        meta = None
+        last_exc: Exception | None = None
+        for _attempt in range(3):
+            try:
+                meta = _load_metadata(RunMetadata, run_json)
+                break
+            except FileNotFoundError as exc:
+                last_exc = exc
+                time.sleep(1)
+
+        if meta is None:
+            raise FileNotFoundError(
+                f"Run metadata not found at {run_json}"
+            ) from last_exc
+        run = _reconstruct(Run, {"experiment": experiment, "metadata": meta})
+        profile_cfg = ProfileConfig(run.metadata.config, name=run.metadata.profile)
+        return cls(run, profile_config=profile_cfg)
 
-        # Reconstruct Run
-        run_meta = RunMetadata(
-            id=run_data["id"],
-            parameters=run_data.get("parameters", {}),
-            assets=run_data.get("assets", {}),
-            created_at=run_data.get("created_at", datetime.now().isoformat()),
-            updated_at=run_data.get("updated_at", datetime.now().isoformat()),
-            status=run_data.get("status", "pending"),
-        )
-        run = _reconstruct(Run, {
-            "experiment": experiment,
-            "metadata": run_meta,
+    def _register_channel(self, name: str, queue: Any) -> None:
+        self._channels[name] = queue
+
+    # ── Internal ────────────────────────────────────────────────────────
+
+    @property
+    def context(self) -> Context:
+        return self._context
+
+    def _load_existing_results(self):
+        run_json = self.work_dir / "run.json"
+        if not run_json.exists() or run_json.stat().st_size == 0:
+            return
+        with open(run_json) as f:
+            data = json.load(f)
+        for key, value in data.get("context", {}).get("results", {}).items():
+            if key not in self._context.results:
+                self._context.results[key] = value
+
+    def _save_context(self):
+        _atomic_write_json(self.work_dir / "run.json", {
+            **self.run.metadata.model_dump(mode="json"),
+            "context": self._context.model_dump(mode="json"),
         })
 
-        # Build RunContext without calling __init__ (to avoid recomputing work_dir)
-        ctx = cls.__new__(cls)
-        ctx.run = run
-        ctx.work_dir = run_dir
-        ctx.artifacts_dir = run_dir / "artifacts"
-        ctx._start_time = None
+    def _next_execution_id(self) -> str:
+        """Return the execution_id for this attempt.
 
-        # Restore context from run.json if available
-        context_data = run_data.get("context", {})
-        ctx._context = Context(
-            run_id=run.id,
-            experiment_id=experiment.id,
-            project_id=project.id,
-            work_dir=run_dir,
-            artifacts_dir=run_dir / "artifacts",
-            tasks=context_data.get("tasks", {}),
-            results=context_data.get("results", {}),
-            status=context_data.get("status", {}),
-            errors=context_data.get("errors", {}),
-            workflow=context_data.get("workflow"),
-            execution=context_data.get("execution", {}),
-        )
+        Mirrors the logic in the workflow runtime so that the directory
+        created by RunStorePersistence and the execution_history entry
+        share the same identifier.
+        """
+        run_id = self.run.id
+        base = f"exec-{run_id}"
+        exec_root = self.work_dir / "execution"
+        if not exec_root.exists():
+            return base
+        existing = [p for p in exec_root.iterdir() if p.name.startswith(base)]
+        if not existing:
+            return base
+        return f"{base}-{len(existing) + 1}"
+
+    def _close_execution_record(
+        self, status: str, finished_at: datetime
+    ) -> list[ExecutionRecord]:
+        """Return execution_history with the current record closed."""
+        history = list(self.run.metadata.execution_history)
+        for i, entry in enumerate(history):
+            if entry.execution_id == self._execution_id:
+                history[i] = entry.model_copy(
+                    update={"finished_at": finished_at, "status": status}
+                )
+                return history
+        return history
+
+    def _append_run_log(self, message: str) -> None:
+        """Append a single timestamped line to logs/run.log."""
+        ts = datetime.now().isoformat(timespec="seconds")
+        with open(self.logs_dir / "run.log", "a") as fh:
+            fh.write(f"{ts}  {message}\n")
+
+    def _apply_profile_metadata(self) -> None:
+        """Persist the active profile name / data / hash into RunMetadata."""
+        labels = dict(self.run.metadata.labels)
+        labels.pop("mode", None)  # legacy key, no longer used
+        cfg = self._profile_config
+        updates: dict[str, Any] = {
+            "profile": cfg.name,
+            "config": cfg.to_dict(),
+            "config_hash": cfg.content_hash() if len(cfg) > 0 or cfg.name else None,
+            "labels": labels,
+        }
+        self.run._update_metadata(**updates)
 
-        return ctx
+    def _claim_ownership(self) -> None:
+        """Stamp the run with the current process identity.
+
+        Stored in ``labels`` as ``pid`` / ``host`` / ``heartbeat``.  A later
+        ``molexp run`` invocation can consult these to tell a live run from a
+        zombie left behind by a crashed process.
+        """
+        labels = dict(self.run.metadata.labels)
+        labels["pid"] = str(os.getpid())
+        labels["host"] = platform.node()
+        labels["heartbeat"] = datetime.now().isoformat()
+        self.run._update_metadata(labels=labels)
+
+    def _labels_without_ownership(self) -> dict[str, str]:
+        """Return labels with the ownership stamp removed."""
+        labels = dict(self.run.metadata.labels)
+        for key in ("pid", "host", "heartbeat"):
+            labels.pop(key, None)
+        return labels
+
+    def _save_error_details(self, exc_type, exc_val, exc_tb):
+        tb_lines = traceback.format_exception(exc_type, exc_val, exc_tb)
+        # Write per-execution error alongside workflow.json in execution/{exec_id}/
+        if self._execution_id is not None:
+            exec_dir = self.work_dir / "execution" / self._execution_id
+            exec_dir.mkdir(parents=True, exist_ok=True)
+            error_dest = exec_dir / "error.txt"
+        else:
+            error_dest = self.logs_dir / "error.txt"
+        with open(error_dest, "w") as f:
+            f.write(f"Error: {datetime.now().isoformat()}\n")
+            f.write(f"Type: {exc_type.__name__}\n")
+            f.write(f"Message: {exc_val}\n\n")
+            f.write("".join(tb_lines))
+
+
+# ── Run ─────────────────────────────────────────────────────────────────────
 
 
 class Run:
-    """Single execution instance with runtime behavior.
-    
-    Construction is side-effect free and auto-generates metadata.
-    Filesystem operations happen explicitly via materialize().
-    
-    Example:
-        >>> # User provides only what they care about
-        >>> run = Run(
-        ...     experiment=experiment,
-        ...     parameters={"lr": 0.001, "batch_size": 32}
-        ... )
-        >>> 
-        >>> # System fields auto-generated
-        >>> assert run.id  # UUID auto-generated
-        >>> assert run.metadata.created_at  # Timestamp auto-generated
-        >>> 
-        >>> # No filesystem side effects yet
-        >>> # Explicitly materialize to disk
-        >>> run.materialize()  # NOW directories/files are created
-        >>> 
-        >>> # Execute workflow with context manager
-        >>> with run.context() as ctx:
-        ...     # Workflow execution
-        ...     engine = WorkflowEngine(workflow)
-        ...     engine.execute(workflow, ctx)
+    """Single execution instance within an experiment.
+
+    Example::
+
+        run = experiment.run(parameters={"lr": 0.001})
+        with run.start() as ctx:
+            result = my_workflow(ctx)
+            ctx.set_result("output", result)
     """
-    
+
     def __init__(
         self,
         experiment: Experiment,
         parameters: dict[str, Any] | None = None,
-        assets: dict[str, Any] | None = None,
         id: str | None = None,
-    ):
-        """Initialize run with user inputs and auto-generate metadata.
-
-        Args:
-            experiment: Parent experiment (runtime dependency)
-            parameters: Execution parameters (user input)
-            assets: Input/output assets (user input)
-            id: Optional custom run ID (if None, auto-generates UUID)
-        """
+        workflow_snapshot: WorkflowSnapshotRef | None = None,
+    ) -> None:
         self.experiment = experiment
-
-        # Auto-generate metadata with system fields
         self.metadata = RunMetadata(
-            id=id or generate_id(),  # Auto-generated UUID if not provided
+            id=id or generate_id(),
             parameters=parameters or {},
-            assets=assets or {},
-            created_at=datetime.now(),  # Auto-generated timestamp
-            updated_at=datetime.now(),
-            status=RunStatus.PENDING,
+            workflow_snapshot=workflow_snapshot,
         )
-    
-    # Property proxies for convenient access to metadata fields
-    
+
+    # ── Properties ──────────────────────────────────────────────────────
+
     @property
     def id(self) -> str:
-        """Run identifier."""
         return self.metadata.id
-    
+
     @property
     def parameters(self) -> dict[str, Any]:
-        """Execution parameters."""
         return self.metadata.parameters
-    
-    @property
-    def assets(self) -> dict[str, Any]:
-        """Input/output assets."""
-        return self.metadata.assets
-    
+
     @property
     def status(self) -> str:
-        """Run execution status."""
         return self.metadata.status
-    
-    @status.setter
-    def status(self, value: str) -> None:
-        """Update run status."""
-        self.metadata.status = value
-        self.metadata.updated_at = datetime.now()
-    
+
+    @property
+    def run_dir(self) -> Path:
+        return self.experiment.experiment_dir / "runs" / f"run-{self.id}"
+
+    # ── Persistence ─────────────────────────────────────────────────────
+
     def materialize(self) -> None:
-        """Create filesystem structure and persist metadata.
+        self.run_dir.mkdir(parents=True, exist_ok=True)
+        _save_metadata(self.metadata, self.run_dir / "run.json")
 
-        This is the explicit side-effect method that:
-        - Creates run directory
-        - Writes metadata JSON file
-        - Initializes any subdirectories
-        """
-        run_dir = (
-            self.experiment.workspace.root / "projects" /
-            self.experiment.project.id / "experiments" /
-            self.experiment.id / "runs" / self.id
-        )
-        run_dir.mkdir(parents=True, exist_ok=True)
-        _save_metadata(self.metadata, run_dir / "run.json")
-    
     def save(self) -> None:
-        """Save updated metadata to disk.
+        _save_metadata(self.metadata, self.run_dir / "run.json")
+
+    # ── Execution ───────────────────────────────────────────────────────
 
-        Updates the metadata file without recreating directory structure.
+    def start(self, profile_config: ProfileConfig | None = None) -> RunContext:
+        """Return a context manager for executing this run.
+
+        *profile_config* selects the active molcfg profile; when omitted
+        the run executes with an empty (defaults-only) :class:`ProfileConfig`.
         """
-        run_dir = (
-            self.experiment.workspace.root / "projects" /
-            self.experiment.project.id / "experiments" /
-            self.experiment.id / "runs" / self.id
+        return RunContext(self, profile_config=profile_config)
+
+    def cancel(self) -> None:
+        """Mark the run as cancelled in workspace metadata."""
+        labels = dict(self.metadata.labels)
+        for key in ("pid", "host", "heartbeat"):
+            labels.pop(key, None)
+        self._update_metadata(
+            status=RunStatus.CANCELLED,
+            finished_at=datetime.now(),
+            labels=labels,
         )
-        self.metadata.updated_at = datetime.now()
-        _save_metadata(self.metadata, run_dir / "run.json")
-    
-    @property
-    def ctx(self) -> RunContext:
-        """Lazily-created RunContext, available without entering the context manager."""
-        if not hasattr(self, '_run_context') or self._run_context is None:
-            self._run_context = RunContext(self)
-        return self._run_context
-
-    @property
-    def work_dir(self) -> Path:
-        """Run working directory."""
-        return self.ctx.work_dir
 
-    def start(self) -> RunContext:
-        """Start the run and return execution context manager.
+    # ── Internal (frozen-metadata mutation helpers) ──────────────────────
 
-        Usage:
-            >>> with run.start() as ctx:
-            ...     engine.execute(run_context=ctx, ...)
+    def _set_status(self, status: RunStatus) -> None:
+        self.metadata = self.metadata.model_copy(update={"status": status.value})
+        self.save()
 
-        Returns:
-            RunContext: Context manager for run execution
-        """
-        return self.ctx
-    
+    def _update_metadata(self, **updates: Any) -> None:
+        self.metadata = self.metadata.model_copy(update=updates)
+        self.save()
diff --git a/src/molexp/workspace/utils.py b/src/molexp/workspace/utils.py
index 198bebec..420d5178 100644
--- a/src/molexp/workspace/utils.py
+++ b/src/molexp/workspace/utils.py
@@ -9,12 +9,12 @@
 
 
 def generate_id() -> str:
-    """Generate a unique run ID using UUID.
-    
+    """Generate a unique 8-character hex run ID.
+
     Returns:
-        UUID string, e.g., 'a3f2e8d9-4b1c-4e5f-9a2b-1c3d4e5f6a7b'
+        8-character hex string, e.g., 'a3f2e8d9'
     """
-    return str(uuid4())
+    return uuid4().hex[:8]
 
 
 def generate_asset_id() -> str:
diff --git a/src/molexp/workspace/workspace.py b/src/molexp/workspace/workspace.py
index 78888e53..68024d7c 100644
--- a/src/molexp/workspace/workspace.py
+++ b/src/molexp/workspace/workspace.py
@@ -1,271 +1,184 @@
-"""Workspace with project management and workspace-level asset library.
+"""Workspace: top-level container with project management.
 
-A Workspace represents the top-level container with runtime behavior.
-Construction auto-generates metadata; persistence happens via materialize().
+The Workspace is the root of the hierarchy.  Unlike lower levels, the
+workspace constructor **does** ensure its root directory + ``workspace.json``
+exist, because every other level needs a materialized workspace as anchor.
+
+Child factories (``.project()``) are idempotent: they load existing
+children from disk or create + materialize new ones.
 """
 
 from __future__ import annotations
 
-import json
-import os
-from datetime import datetime
+import shutil
 from pathlib import Path
-from typing import Any
 
 from .asset import AssetLibrary
-from .base import _save_metadata, _load_metadata, _reconstruct, _list_children
-from .metadata import WorkspaceMetadata, ProjectMetadata
+from .base import _list_children, _load_metadata, _reconstruct, _save_metadata
+from .models import ProjectMetadata, WorkspaceMetadata
 from .project import Project
 from .utils import slugify
 
 
 class Workspace:
     """Top-level workspace with project management and global asset library.
-    
-    Construction is side-effect free and auto-generates metadata.
-    Filesystem operations happen explicitly via materialize().
-    
-    Each workspace has its own asset library for workspace-level (global) assets.
-    
-    Example:
-        >>> # User provides only what they care about
-        >>> workspace = Workspace(root="./my_workspace", name="My Workspace")
-        >>> 
-        >>> # System fields auto-generated
-        >>> assert workspace.id  # Slugified from name
-        >>> assert workspace.metadata.created_at  # Timestamp auto-generated
-        >>> 
-        >>> # No filesystem side effects yet
-        >>> # Explicitly materialize to disk
-        >>> workspace.materialize()  # NOW directories/files are created
-        >>> 
-        >>> # Create project
-        >>> project = workspace.create_project(name="QM9 Energy Prediction")
+
+    Example::
+
+        ws = Workspace("./lab")
+        project = ws.project("QM9")
+        exp = project.experiment("baseline", params={"lr": 1e-3}, n_replicas=3)
     """
-    
-    def __init__(self, root: Path | str, name: str | None = None):
-        """Initialize workspace with user inputs and auto-generate metadata.
-        
-        Args:
-            root: Root directory for workspace (user input)
-            name: Human-readable workspace name (user input, defaults to root basename)
-        """
+
+    def __init__(self, root: Path | str, name: str | None = None) -> None:
         self.root = Path(root).resolve()
-        
-        # Default name to root directory basename if not provided
-        if name is None:
-            name = self.root.name
-        
-        # Auto-generate metadata with system fields
-        self.metadata = WorkspaceMetadata(
-            id=slugify(name),  # Auto-generated from name
-            name=name,
-            created_at=datetime.now(),  # Auto-generated timestamp
-            updated_at=datetime.now(),
-        )
-        
-        # Runtime-only state
-        self._assets_lib = None
-    
-    # Property proxies for convenient access to metadata fields
-    
+        metadata_file = self.root / "workspace.json"
+        if metadata_file.exists():
+            self.metadata = _load_metadata(WorkspaceMetadata, metadata_file)
+        else:
+            if name is None:
+                name = self.root.name
+            self.metadata = WorkspaceMetadata(id=slugify(name), name=name)
+        self._assets_lib: AssetLibrary | None = None
+        self._projects_cache: dict[str, Project] = {}
+
+    def _ensure_materialized(self) -> None:
+        if not (self.root / "workspace.json").exists():
+            self.materialize()
+
+    # ── Properties ──────────────────────────────────────────────────────
+
     @property
     def id(self) -> str:
-        """Workspace identifier."""
         return self.metadata.id
-    
+
     @property
     def name(self) -> str:
-        """Human-readable workspace name."""
         return self.metadata.name
-    
+
     @property
     def created_at(self):
-        """Creation timestamp."""
         return self.metadata.created_at
-    
-    @property
-    def updated_at(self):
-        """Last update timestamp."""
-        return self.metadata.updated_at
-    
+
     @property
     def assets(self) -> AssetLibrary:
-        """Workspace-level asset library."""
         if self._assets_lib is None:
             self._assets_lib = AssetLibrary(self.root / "assets")
         return self._assets_lib
-    
-    def materialize(self) -> None:
-        """Create filesystem structure and persist metadata.
 
-        This is the explicit side-effect method that:
-        - Creates workspace root directory
-        - Writes metadata JSON file
-        - Initializes subdirectories (assets, projects)
-        """
+    # ── Persistence ─────────────────────────────────────────────────────
+
+    def materialize(self) -> None:
+        """Create filesystem structure and persist metadata (non-recursive)."""
         self.root.mkdir(parents=True, exist_ok=True)
         _save_metadata(self.metadata, self.root / "workspace.json")
 
     def save(self) -> None:
-        """Save updated metadata to disk."""
-        self.metadata.updated_at = datetime.now()
+        """Persist current metadata to disk."""
         _save_metadata(self.metadata, self.root / "workspace.json")
-    
-    @classmethod
-    def from_env(cls, env_var: str = "MOLEXP_WORKSPACE") -> Workspace:
-        """Create workspace from environment variable or current directory.
-        
-        Args:
-            env_var: Environment variable name (default: MOLEXP_WORKSPACE)
-            
-        Returns:
-            Workspace instance loaded from disk
-        """
-        workspace_path = os.environ.get(env_var)
-        if workspace_path:
-            return cls.load(Path(workspace_path))
-        return cls.load(Path.cwd())
-    
+
+    # ── Alternative constructors (kept for callers that still use them) ──
+
     @classmethod
     def load(cls, root: Path | str) -> Workspace:
-        """Load workspace from disk.
-        
-        Args:
-            root: Path to workspace root
-            
-        Returns:
-            Workspace instance loaded from metadata
-        """
+        """Load an existing workspace from disk (raises if missing)."""
         root = Path(root).resolve()
         metadata_file = root / "workspace.json"
         if not metadata_file.exists():
-            raise FileNotFoundError(f"Workspace metadata not found at {metadata_file}")
-
-        workspace_metadata = _load_metadata(WorkspaceMetadata, metadata_file)
-        return _reconstruct(cls, {
-            "root": root,
-            "metadata": workspace_metadata,
-            "_assets_lib": None,
-        })
+            raise FileNotFoundError(
+                f"Workspace metadata not found at {metadata_file}"
+            )
+        meta = _load_metadata(WorkspaceMetadata, metadata_file)
+        return _reconstruct(
+            cls,
+            {
+                "root": root,
+                "metadata": meta,
+                "_assets_lib": None,
+                "_projects_cache": {},
+            },
+        )
 
     @classmethod
     def from_path(cls, root: Path | str) -> Workspace:
-        """Load an existing workspace or initialize a new one at path.
-
-        If workspace metadata exists, it is loaded. Otherwise a new workspace is
-        created and materialized on disk.
-        """
-        root = Path(root).resolve()
-        metadata_file = root / "workspace.json"
-        if metadata_file.exists():
-            return cls.load(root)
+        """Compatibility alias for ``Workspace(root)``."""
+        return cls(root)
 
-        workspace = cls(root=root, name=root.name)
-        workspace.materialize()
-        return workspace
-    
-    # ============ Project Operations ============
-    
-    def create_project(self, name: str, exist_ok: bool = False) -> Project:
-        """Create a new project.
+    # ── Project operations ──────────────────────────────────────────────
 
-        Args:
-            name: Human-readable project name (user input)
-            exist_ok: If True, load existing project instead of raising error
+    def project(self, name: str) -> Project:
+        """Get-or-create a project (idempotent, materialized immediately).
 
-        Returns:
-            Created Project (already materialized)
-
-        Raises:
-            ValueError: If project with this ID already exists and exist_ok=False
+        Within the same process, repeated calls with the same name return
+        the **same** Project instance — preserving in-memory state such as
+        bound workflows on child experiments.
         """
-        # Construct project (no side effects)
-        project = Project(name=name, workspace=self)
-
-        # Check if project already exists
-        project_dir = self.root / "projects" / project.id
+        self._ensure_materialized()
+        project_id = slugify(name)
+        if project_id in self._projects_cache:
+            return self._projects_cache[project_id]
+        project_dir = self.root / "projects" / project_id
         if project_dir.exists():
-            if exist_ok:
-                # Load existing project
-                metadata_file = project_dir / "project.json"
-                if metadata_file.exists():
-                    from .base import _load_metadata, _reconstruct
-                    from .metadata import ProjectMetadata
-                    metadata = _load_metadata(ProjectMetadata, metadata_file)
-                    attrs = {
-                        'metadata': metadata,
-                        'workspace': self,
-                        '_assets_lib': None,
-                    }
-                    return _reconstruct(Project, attrs)
-            raise ValueError(f"Project '{project.id}' already exists")
-
-        # Explicitly materialize
-        project.materialize()
-
-        # Register project in workspace metadata
-        if project.id not in self.metadata.projects:
-            self.metadata.projects.append(project.id)
-            self.save()
-
+            project = self._load_project_from_dir(project_dir)
+        else:
+            project = Project(name=name, workspace=self)
+            project.materialize()
+        self._projects_cache[project_id] = project
         return project
-    
-    def get_project(self, name_or_id: str) -> Project | None:
-        """Get project by name or ID (load from disk).
-        
-        Args:
-            name_or_id: Project name or id
-            
-        Returns:
-            Project object if found, None otherwise
-        """
-        # Try as ID first
-        id = name_or_id
-        project_dir = self.root / "projects" / id
-
-        # If not found, try as name (slugified)
-        if not project_dir.exists():
-            id = slugify(name_or_id)
-            project_dir = self.root / "projects" / id
 
-        if not project_dir.exists():
-            return None
+    def get_project(self, name_or_id: str) -> Project | None:
+        """Get project by name or slugified ID."""
+        for candidate in (name_or_id, slugify(name_or_id)):
+            if candidate in self._projects_cache:
+                return self._projects_cache[candidate]
+            project_dir = self.root / "projects" / candidate
+            if project_dir.exists():
+                project = self._load_project_from_dir(project_dir)
+                self._projects_cache[project.id] = project
+                return project
+        return None
 
-        metadata_file = project_dir / "project.json"
-        project_metadata = _load_metadata(ProjectMetadata, metadata_file)
-        return _reconstruct(Project, {
-            "workspace": self,
-            "metadata": project_metadata,
-            "_assets_lib": None,
-        })
-    
     def list_projects(self) -> list[Project]:
-        """List all projects.
-
-        Returns:
-            List of Project objects
-        """
-        return _list_children(
+        """List all projects (disk scan merged with in-memory cache)."""
+        seen: dict[str, Project] = dict(self._projects_cache)
+        scanned = _list_children(
             children_dir=self.root / "projects",
             metadata_filename="project.json",
             metadata_cls=ProjectMetadata,
             child_cls=Project,
-            attrs_factory=lambda m: {"workspace": self, "metadata": m, "_assets_lib": None},
+            attrs_factory=lambda m: {
+                "workspace": self,
+                "metadata": m,
+                "_assets_lib": None,
+                "_experiments_cache": {},
+            },
         )
-    
-    def delete_project(self, id: str) -> None:
-        """Delete project.
-        
-        Args:
-            id: Project identifier
-            
+        for p in scanned:
+            seen.setdefault(p.id, p)
+        return list(seen.values())
+
+    def delete_project(self, project_id: str) -> None:
+        """Delete project directory.
+
         Raises:
-            KeyError: If project not found
+            KeyError: If project not found.
         """
-        project_dir = self.root / "projects" / id
+        project_dir = self.root / "projects" / project_id
         if not project_dir.exists():
-            raise KeyError(f"Project '{id}' not found")
-        
-        import shutil
+            raise KeyError(f"Project '{project_id}' not found")
         shutil.rmtree(project_dir)
+        self._projects_cache.pop(project_id, None)
+
+    # ── Internal ────────────────────────────────────────────────────────
+
+    def _load_project_from_dir(self, project_dir: Path) -> Project:
+        meta = _load_metadata(ProjectMetadata, project_dir / "project.json")
+        return _reconstruct(
+            Project,
+            {
+                "workspace": self,
+                "metadata": meta,
+                "_assets_lib": None,
+                "_experiments_cache": {},
+            },
+        )
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/__pycache__/conftest.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/conftest.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index a690f3f8..00000000
Binary files a/tests/__pycache__/conftest.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_assets.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_assets.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 3ffb0871..00000000
Binary files a/tests/__pycache__/test_assets.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_compiler.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_compiler.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index cb668fbe..00000000
Binary files a/tests/__pycache__/test_compiler.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_control_flow.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_control_flow.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 657a3592..00000000
Binary files a/tests/__pycache__/test_control_flow.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_dsl.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_dsl.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 677217b2..00000000
Binary files a/tests/__pycache__/test_dsl.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_engine.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_engine.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 69d18419..00000000
Binary files a/tests/__pycache__/test_engine.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_id_utils.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_id_utils.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 8d5536bc..00000000
Binary files a/tests/__pycache__/test_id_utils.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_integration.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_integration.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 0aed179c..00000000
Binary files a/tests/__pycache__/test_integration.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_ir_implementation.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_ir_implementation.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 18ef0e27..00000000
Binary files a/tests/__pycache__/test_ir_implementation.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_models.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_models.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 9a8669c8..00000000
Binary files a/tests/__pycache__/test_models.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_task.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_task.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 65c6ae68..00000000
Binary files a/tests/__pycache__/test_task.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/__pycache__/test_workflow_nodes.cpython-312-pytest-7.4.4.pyc b/tests/__pycache__/test_workflow_nodes.cpython-312-pytest-7.4.4.pyc
deleted file mode 100644
index 04b012d5..00000000
Binary files a/tests/__pycache__/test_workflow_nodes.cpython-312-pytest-7.4.4.pyc and /dev/null differ
diff --git a/tests/conftest.py b/tests/conftest.py
index 8f03db53..e1df43e0 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,8 +1 @@
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ROOT / "src"))
-sys.path.insert(0, str(ROOT))
+"""Root-level test configuration."""
diff --git a/tests/test_api_schema.py b/tests/test_api_schema.py
deleted file mode 100644
index baf24cd9..00000000
--- a/tests/test_api_schema.py
+++ /dev/null
@@ -1,82 +0,0 @@
-from __future__ import annotations
-
-from typing import Generator
-
-from fastapi.testclient import TestClient
-
-from molexp.server.app import create_app
-from molexp.server.dependencies import get_workspace
-from molexp.workspace import Workspace
-
-
-def build_workspace(tmp_path) -> tuple[Workspace, str, str, str]:
-    workspace = Workspace(root=tmp_path, name="Test Workspace")
-    workspace.materialize()
-
-    project = workspace.create_project(name="Project Alpha")
-    experiment = project.create_experiment(name="Experiment One")
-    run = experiment.create_run(parameters={"alpha": 1})
-
-    return workspace, project.id, experiment.id, run.id
-
-
-def build_client(workspace: Workspace) -> Generator[TestClient, None, None]:
-    app = create_app()
-    app.dependency_overrides[get_workspace] = lambda: workspace
-    client = TestClient(app)
-    try:
-        yield client
-    finally:
-        app.dependency_overrides.clear()
-
-
-def test_project_experiment_run_schema_ids(tmp_path) -> None:
-    workspace, project_id, experiment_id, run_id = build_workspace(tmp_path)
-
-    for client in build_client(workspace):
-        projects_response = client.get("/api/projects")
-        assert projects_response.status_code == 200
-        projects = projects_response.json()
-        assert len(projects) == 1
-        project = projects[0]
-        assert project["id"] == project_id
-        assert project["projectId"] == project_id
-
-        experiment_list_response = client.get(f"/api/projects/{project_id}/experiments")
-        assert experiment_list_response.status_code == 200
-        experiments = experiment_list_response.json()
-        assert len(experiments) == 1
-        experiment = experiments[0]
-        assert experiment["id"] == experiment_id
-        assert experiment["experimentId"] == experiment_id
-        assert experiment["projectId"] == project_id
-
-        experiment_detail_response = client.get(
-            f"/api/projects/{project_id}/experiments/{experiment_id}"
-        )
-        assert experiment_detail_response.status_code == 200
-        experiment_detail = experiment_detail_response.json()
-        assert experiment_detail["projectId"] == project_id
-        assert experiment_detail["experimentId"] == experiment_id
-
-        run_list_response = client.get(
-            f"/api/projects/{project_id}/experiments/{experiment_id}/runs"
-        )
-        assert run_list_response.status_code == 200
-        runs = run_list_response.json()
-        assert len(runs) == 1
-        run_item = runs[0]
-        assert run_item["id"] == run_id
-        assert run_item["runId"] == run_id
-        assert run_item["projectId"] == project_id
-        assert run_item["experimentId"] == experiment_id
-
-        run_detail_response = client.get(
-            f"/api/projects/{project_id}/experiments/{experiment_id}/runs/{run_id}"
-        )
-        assert run_detail_response.status_code == 200
-        run_detail = run_detail_response.json()
-        assert run_detail["id"] == run_id
-        assert run_detail["runId"] == run_id
-        assert run_detail["projectId"] == project_id
-        assert run_detail["experimentId"] == experiment_id
diff --git a/tests/test_asset_library.py b/tests/test_asset_library.py
deleted file mode 100644
index 775f85d0..00000000
--- a/tests/test_asset_library.py
+++ /dev/null
@@ -1,148 +0,0 @@
-"""Tests for asset library and workflows."""
-
-from __future__ import annotations
-
-import tempfile
-from pathlib import Path
-
-import pytest
-
-from molexp.workspace.asset import Asset, AssetLibrary, AssetWorkflow
-from molexp.workspace.resource import FileResource
-
-
-def test_asset_library_create_asset():
-    """Test creating asset from path."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        library_root = Path(tmpdir) / "library"
-        source_file = Path(tmpdir) / "source.txt"
-        source_file.write_text("test data")
-        
-        library = AssetLibrary(library_root)
-        
-        # Create asset
-        asset = library.create_asset("test_asset", source_file)
-        
-        # Verify asset properties
-        assert asset.name == "test_asset"
-        assert asset.asset_id is not None  # Auto-generated
-        assert asset.created_at is not None  # Auto-generated
-        assert asset.uri == f"asset://{asset.asset_id}"
-        
-        # Verify asset was stored
-        assert (library_root / asset.asset_id / "data").exists()
-        
-        # Verify we can retrieve it
-        retrieved = library.get_asset("test_asset")
-        assert retrieved.asset_id == asset.asset_id
-        assert retrieved.name == "test_asset"
-
-
-def test_asset_library_add_asset():
-    """Test adding asset from resource."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        library_root = Path(tmpdir) / "library"
-        source_file = Path(tmpdir) / "source.txt"
-        source_file.write_text("test data")
-        
-        library = AssetLibrary(library_root)
-        resource = FileResource(f"file://{source_file}")
-        
-        # Add asset
-        asset = library.add_asset("test_asset", resource)
-        
-        # Verify asset properties
-        assert asset.name == "test_asset"
-        assert asset.asset_id is not None  # Auto-generated
-        assert asset.created_at is not None  # Auto-generated
-        
-        # Verify we can retrieve it
-        retrieved = library.get_asset("test_asset")
-        assert retrieved.asset_id == asset.asset_id
-
-
-def test_asset_library_duplicate_name():
-    """Test that duplicate asset names raise error."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        library_root = Path(tmpdir) / "library"
-        source_file = Path(tmpdir) / "source.txt"
-        source_file.write_text("test data")
-        
-        library = AssetLibrary(library_root)
-        
-        # Create first asset
-        library.create_asset("test_asset", source_file)
-        
-        # Try to create duplicate
-        with pytest.raises(ValueError, match="already exists"):
-            library.create_asset("test_asset", source_file)
-
-
-def test_asset_library_list_assets():
-    """Test listing all assets."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        library_root = Path(tmpdir) / "library"
-        
-        library = AssetLibrary(library_root)
-        
-        # Create multiple assets
-        for i in range(3):
-            source_file = Path(tmpdir) / f"source{i}.txt"
-            source_file.write_text(f"data {i}")
-            library.create_asset(f"asset_{i}", source_file)
-        
-        # List assets
-        assets = library.list_assets()
-        assert len(assets) == 3
-        assert {a.name for a in assets} == {"asset_0", "asset_1", "asset_2"}
-
-
-def test_asset_workflow():
-    """Test asset workflow execution."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        library_root = Path(tmpdir) / "library"
-        library = AssetLibrary(library_root)
-        
-        # Define workflow steps
-        def step1(**kwargs):
-            # Create a file
-            file_path = Path(tmpdir) / "workflow_output.txt"
-            file_path.write_text("workflow data")
-            return {"asset_path": str(file_path)}
-        
-        def step2(**kwargs):
-            # Add asset name
-            return {"asset_name": "workflow_asset"}
-        
-        # Create and register workflow
-        workflow = AssetWorkflow("test_workflow", [step1, step2])
-        library.add_workflow("test_workflow", workflow)
-        
-        # Execute workflow
-        asset = library.run_workflow("test_workflow")
-        
-        # Verify asset was created
-        assert asset.name == "workflow_asset"
-        assert asset.asset_id is not None
-        
-        # Verify we can retrieve it
-        retrieved = library.get_asset("workflow_asset")
-        assert retrieved.asset_id == asset.asset_id
-
-
-def test_asset_workflow_missing_keys():
-    """Test workflow fails if final step doesn't return required keys."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        library_root = Path(tmpdir) / "library"
-        library = AssetLibrary(library_root)
-        
-        # Define workflow that doesn't return required keys
-        def bad_step(**kwargs):
-            return {"some_key": "value"}
-        
-        workflow = AssetWorkflow("bad_workflow", [bad_step])
-        library.add_workflow("bad_workflow", workflow)
-        
-        # Execute workflow should fail
-        with pytest.raises(ValueError, match="must return 'asset_name' and 'asset_path'"):
-            library.run_workflow("bad_workflow")
diff --git a/tests/test_checkpoint.py b/tests/test_checkpoint.py
deleted file mode 100644
index a80fdb25..00000000
--- a/tests/test_checkpoint.py
+++ /dev/null
@@ -1,155 +0,0 @@
-"""Tests for checkpoint functionality."""
-
-import json
-import tempfile
-from datetime import datetime
-from pathlib import Path
-
-import pytest
-
-from molexp.workspace.checkpoint import (
-    Checkpoint,
-    CheckpointState,
-    generate_checkpoint_id,
-)
-
-
-def test_generate_checkpoint_id():
-    """Test checkpoint ID generation."""
-    ckpt_id = generate_checkpoint_id()
-    
-    assert ckpt_id.startswith("ckpt_")
-    assert len(ckpt_id) > 5  # ckpt_ + some hex digits
-
-
-def test_checkpoint_state_creation():
-    """Test CheckpointState model creation."""
-    state = CheckpointState(
-        name="test_checkpoint",
-        ckpt_id="ckpt_test123",
-        run_id="run_123",
-        experiment_id="exp_456",
-        project_id="proj_789",
-        timestamp=datetime.now(),
-        context={"tasks": {}, "results": {}},
-        metadata={"note": "test"}
-    )
-    
-    assert state.name == "test_checkpoint"
-    assert state.ckpt_id == "ckpt_test123"
-    assert state.run_id == "run_123"
-    assert state.metadata["note"] == "test"
-
-
-def test_checkpoint_save_and_load():
-    """Test checkpoint save and load roundtrip."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        checkpoint_dir = Path(tmpdir) / ".ckpt"
-        
-        # Create checkpoint state
-        state = CheckpointState(
-            name="test",
-            ckpt_id="ckpt_test123",
-            run_id="run_123",
-            experiment_id="exp_456",
-            project_id="proj_789",
-            timestamp=datetime.now(),
-            context={"tasks": {"task1": "completed"}},
-            metadata={}
-        )
-        
-        # Save checkpoint
-        checkpoint_path = Checkpoint.save(checkpoint_dir, state)
-        
-        # Verify file exists
-        assert checkpoint_path.exists()
-        assert checkpoint_path.parent == checkpoint_dir
-        
-        # Verify latest symlink
-        latest = checkpoint_dir / "latest.json"
-        assert latest.exists()
-        assert latest.is_symlink()
-        
-        # Load checkpoint
-        loaded_state = Checkpoint.load(checkpoint_path)
-        
-        # Verify loaded data
-        assert loaded_state.name == state.name
-        assert loaded_state.ckpt_id == state.ckpt_id
-        assert loaded_state.run_id == state.run_id
-        assert loaded_state.context["tasks"]["task1"] == "completed"
-
-
-def test_checkpoint_get_latest():
-    """Test getting latest checkpoint."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        checkpoint_dir = Path(tmpdir) / ".ckpt"
-        
-        # No checkpoint yet
-        latest = Checkpoint.get_latest(checkpoint_dir)
-        assert latest is None
-        
-        # Create first checkpoint
-        state1 = CheckpointState(
-            ckpt_id="ckpt_001",
-            run_id="run_123",
-            experiment_id="exp_456",
-            project_id="proj_789",
-            timestamp=datetime.now(),
-            context={}
-        )
-        Checkpoint.save(checkpoint_dir, state1)
-        
-        # Get latest
-        latest = Checkpoint.get_latest(checkpoint_dir)
-        assert latest is not None
-        assert latest.ckpt_id == "ckpt_001"
-        
-        # Create second checkpoint
-        state2 = CheckpointState(
-            ckpt_id="ckpt_002",
-            run_id="run_123",
-            experiment_id="exp_456",
-            project_id="proj_789",
-            timestamp=datetime.now(),
-            context={}
-        )
-        Checkpoint.save(checkpoint_dir, state2)
-        
-        # Latest should be second checkpoint
-        latest = Checkpoint.get_latest(checkpoint_dir)
-        assert latest.ckpt_id == "ckpt_002"
-
-
-def test_checkpoint_json_format():
-    """Test checkpoint JSON file format."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        checkpoint_dir = Path(tmpdir) / ".ckpt"
-        
-        state = CheckpointState(
-            name="milestone1",
-            ckpt_id="ckpt_test123",
-            run_id="run_123",
-            experiment_id="exp_456",
-            project_id="proj_789",
-            timestamp=datetime.now(),
-            context={"tasks": {"task1": "completed"}},
-            metadata={"epoch": 10}
-        )
-        
-        checkpoint_path = Checkpoint.save(checkpoint_dir, state)
-        
-        # Read and verify JSON structure
-        with open(checkpoint_path) as f:
-            data = json.load(f)
-        
-        assert "name" in data
-        assert "ckpt_id" in data
-        assert "run_id" in data
-        assert "timestamp" in data
-        assert "version" in data
-        assert "context" in data
-        assert "metadata" in data
-        
-        assert data["name"] == "milestone1"
-        assert data["metadata"]["epoch"] == 10
diff --git a/tests/test_cli_cancel.py b/tests/test_cli_cancel.py
new file mode 100644
index 00000000..6bc63209
--- /dev/null
+++ b/tests/test_cli_cancel.py
@@ -0,0 +1,292 @@
+"""CLI tests for `molexp runs cancel`."""
+
+from __future__ import annotations
+
+import pytest
+from typer.testing import CliRunner
+
+from molexp.cli import app
+from molexp.workspace import Workspace
+from molexp.workspace.run import RunStatus
+
+runner = CliRunner()
+
+
+def _make_workspace(tmp_path, status="pending", molq_job_id=None, slurm_job_id=None):
+    """Create a minimal workspace/project/experiment/run for testing."""
+    ws_path = tmp_path / "workspace"
+    ws = Workspace(root=ws_path, name="test-ws")
+    project = ws.project("proj1")
+    exp = project.experiment("exp1")
+    run = exp.run(parameters={"lr": 0.001})
+    if status != "pending":
+        run._set_status(RunStatus(status))
+    if molq_job_id or slurm_job_id:
+        executor_info: dict[str, str] = {}
+        if molq_job_id:
+            executor_info["job_id"] = molq_job_id
+        if slurm_job_id:
+            executor_info["scheduler_job_id"] = slurm_job_id
+        run._update_metadata(executor_info=executor_info)
+    return ws_path, project, exp, run
+
+
+class TestRunsCancelExperimentScope:
+    def test_cancel_all_pending_runs(self, tmp_path):
+        ws_path, project, exp, run = _make_workspace(tmp_path)
+
+        result = runner.invoke(app, [
+            "runs", "cancel",
+            "--project", project.id,
+            "--experiment", exp.id,
+            "--all", "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0, result.output
+        reloaded = Workspace.load(ws_path).get_project(project.id).get_experiment(exp.id).get_run(run.id)
+        assert reloaded.status == "cancelled"
+
+    def test_cancel_by_status_filter(self, tmp_path):
+        ws_path, project, exp, run = _make_workspace(tmp_path, status="running")
+
+        result = runner.invoke(app, [
+            "runs", "cancel",
+            "--project", project.id,
+            "--experiment", exp.id,
+            "--status", "running", "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0, result.output
+        reloaded = Workspace.load(ws_path).get_project(project.id).get_experiment(exp.id).get_run(run.id)
+        assert reloaded.status == "cancelled"
+
+    def test_cancel_skips_terminal_runs(self, tmp_path):
+        ws_path, project, exp, run = _make_workspace(tmp_path, status="succeeded")
+
+        result = runner.invoke(app, [
+            "runs", "cancel",
+            "--project", project.id,
+            "--experiment", exp.id,
+            "--all", "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0, result.output
+        # In experiment-scope --all mode, terminal runs are excluded before selection,
+        # so the message is "nothing to cancel" rather than "already terminal".
+        assert "nothing to cancel" in result.output or "terminal" in result.output
+        reloaded = Workspace.load(ws_path).get_project(project.id).get_experiment(exp.id).get_run(run.id)
+        assert reloaded.status == "succeeded"
+
+    def test_cancel_no_matching_runs(self, tmp_path):
+        ws_path, project, exp, _ = _make_workspace(tmp_path, status="succeeded")
+
+        result = runner.invoke(app, [
+            "runs", "cancel",
+            "--project", project.id,
+            "--experiment", exp.id,
+            "--status", "running",
+            "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0, result.output
+        assert "No runs matched" in result.output
+
+    def test_cancel_requires_all_or_status(self, tmp_path):
+        ws_path, project, exp, _ = _make_workspace(tmp_path)
+
+        result = runner.invoke(app, [
+            "runs", "cancel",
+            "--project", project.id,
+            "--experiment", exp.id,
+            "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 1
+        assert "--all or --status" in result.output
+
+    def test_cancel_requires_both_project_and_experiment(self, tmp_path):
+        ws_path, project, _, _ = _make_workspace(tmp_path)
+
+        result = runner.invoke(app, [
+            "runs", "cancel",
+            "--project", project.id,
+            "--all", "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 1
+        assert "--project and --experiment" in result.output
+
+    def test_cancel_aborted_by_user(self, tmp_path):
+        ws_path, project, exp, run = _make_workspace(tmp_path)
+
+        result = runner.invoke(app, [
+            "runs", "cancel",
+            "--project", project.id,
+            "--experiment", exp.id,
+            "--all",
+            "--path", str(ws_path),
+        ], input="N\n")
+
+        assert result.exit_code == 0
+        assert "Aborted" in result.output
+        reloaded = Workspace.load(ws_path).get_project(project.id).get_experiment(exp.id).get_run(run.id)
+        assert reloaded.status == "pending"
+
+    def test_cancel_shows_confirmation_table(self, tmp_path):
+        ws_path, project, exp, run = _make_workspace(tmp_path)
+
+        result = runner.invoke(app, [
+            "runs", "cancel",
+            "--project", project.id,
+            "--experiment", exp.id,
+            "--all", "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0
+        assert "Runs to cancel" in result.output
+
+
+class TestRunsCancelByRunId:
+    def test_cancel_by_explicit_run_id(self, tmp_path):
+        ws_path, project, exp, run = _make_workspace(tmp_path)
+
+        result = runner.invoke(app, [
+            "runs", "cancel", run.id,
+            "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0, result.output
+        reloaded = Workspace.load(ws_path).get_project(project.id).get_experiment(exp.id).get_run(run.id)
+        assert reloaded.status == "cancelled"
+
+    def test_cancel_by_run_id_skips_terminal(self, tmp_path):
+        ws_path, project, exp, run = _make_workspace(tmp_path, status="succeeded")
+
+        result = runner.invoke(app, [
+            "runs", "cancel", run.id,
+            "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0
+        assert "terminal" in result.output
+        reloaded = Workspace.load(ws_path).get_project(project.id).get_experiment(exp.id).get_run(run.id)
+        assert reloaded.status == "succeeded"
+
+    def test_cancel_unknown_run_id_warns(self, tmp_path):
+        ws_path, _, _, _ = _make_workspace(tmp_path)
+
+        result = runner.invoke(app, [
+            "runs", "cancel", "nonexistent-run-id",
+            "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0
+        assert "not found" in result.output.lower()
+
+
+class TestRunsCancelMolqIntegration:
+    def test_cancel_calls_molq_when_job_id_present(self, tmp_path, mocker):
+        ws_path, project, exp, run = _make_workspace(
+            tmp_path, molq_job_id="molq-uuid-1234"
+        )
+
+        mock_submitor = mocker.MagicMock()
+        mock_molq = mocker.MagicMock()
+        mock_molq.Submitor = mocker.MagicMock(return_value=mock_submitor)
+        mocker.patch.dict("sys.modules", {"molq": mock_molq})
+
+        result = runner.invoke(app, [
+            "runs", "cancel", run.id,
+            "--yes", "--scheduler", "slurm",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0, result.output
+        mock_molq.Submitor.assert_called_once_with(cluster_name="default", scheduler="slurm")
+        mock_submitor.cancel.assert_called_once_with("molq-uuid-1234")
+
+    def test_cancel_updates_workspace_when_molq_fails(self, tmp_path, mocker):
+        ws_path, project, exp, run = _make_workspace(
+            tmp_path, molq_job_id="molq-uuid-5678"
+        )
+
+        mock_submitor = mocker.MagicMock()
+        mock_submitor.cancel.side_effect = RuntimeError("scancel failed")
+        mock_molq = mocker.MagicMock()
+        mock_molq.Submitor = mocker.MagicMock(return_value=mock_submitor)
+        mocker.patch.dict("sys.modules", {"molq": mock_molq})
+
+        result = runner.invoke(app, [
+            "runs", "cancel", run.id,
+            "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0
+        assert "Warning" in result.output
+        reloaded = Workspace.load(ws_path).get_project(project.id).get_experiment(exp.id).get_run(run.id)
+        assert reloaded.status == "cancelled"
+
+    def test_cancel_warns_when_no_molq_job_id(self, tmp_path, mocker):
+        ws_path, project, exp, run = _make_workspace(tmp_path)
+
+        mock_submitor = mocker.MagicMock()
+        mock_molq = mocker.MagicMock()
+        mock_molq.Submitor = mocker.MagicMock(return_value=mock_submitor)
+        mocker.patch.dict("sys.modules", {"molq": mock_molq})
+
+        result = runner.invoke(app, [
+            "runs", "cancel", run.id,
+            "--yes",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0
+        assert "no molq job metadata" in result.output
+        mock_submitor.cancel.assert_not_called()
+        reloaded = Workspace.load(ws_path).get_project(project.id).get_experiment(exp.id).get_run(run.id)
+        assert reloaded.status == "cancelled"
+
+    def test_cancel_local_scheduler_skips_molq(self, tmp_path):
+        ws_path, project, exp, run = _make_workspace(
+            tmp_path, molq_job_id="molq-uuid-local"
+        )
+
+        result = runner.invoke(app, [
+            "runs", "cancel", run.id,
+            "--yes", "--scheduler", "local",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0
+        reloaded = Workspace.load(ws_path).get_project(project.id).get_experiment(exp.id).get_run(run.id)
+        assert reloaded.status == "cancelled"
+
+    def test_cancel_uses_custom_cluster_name(self, tmp_path, mocker):
+        ws_path, project, exp, run = _make_workspace(
+            tmp_path, molq_job_id="molq-uuid-custom"
+        )
+
+        mock_submitor = mocker.MagicMock()
+        mock_molq = mocker.MagicMock()
+        mock_molq.Submitor = mocker.MagicMock(return_value=mock_submitor)
+        mocker.patch.dict("sys.modules", {"molq": mock_molq})
+
+        result = runner.invoke(app, [
+            "runs", "cancel", run.id,
+            "--yes", "--scheduler", "slurm", "--cluster", "alvis",
+            "--path", str(ws_path),
+        ])
+
+        assert result.exit_code == 0
+        mock_molq.Submitor.assert_called_once_with(cluster_name="alvis", scheduler="slurm")
diff --git a/tests/test_cli_molq.py b/tests/test_cli_molq.py
new file mode 100644
index 00000000..d90dd120
--- /dev/null
+++ b/tests/test_cli_molq.py
@@ -0,0 +1,192 @@
+"""CLI and plugin tests for molq-backed execution."""
+
+from __future__ import annotations
+
+import sys
+from types import ModuleType, SimpleNamespace
+
+from typer.testing import CliRunner
+
+from molexp.cli import app
+from molexp.plugins.submit_molq.submit import make_submit_handler
+from molexp.workspace import Workspace
+
+runner = CliRunner()
+
+
+def _make_workspace(tmp_path):
+    workspace = Workspace(root=tmp_path / "workspace", name="Test")
+    project = workspace.project("demo")
+    experiment = project.experiment("train")
+    run = experiment.run(parameters={"seed": 0})
+    return workspace, experiment, run
+
+
+def test_run_scheduler_uses_generic_molq_backend(monkeypatch, tmp_path):
+    script = tmp_path / "train.py"
+    workspace_root = tmp_path / "workspace"
+    script.write_text(
+        "\n".join(
+            [
+                "import molexp as me",
+                "",
+                f"ws = me.Workspace({str(workspace_root)!r})",
+                "project = ws.project('demo')",
+                "exp = project.experiment('train')",
+                "",
+                "def train(ctx: me.RunContext) -> None:",
+                "    ctx.set_result('ok', True)",
+                "",
+                "exp.set_workflow(train)",
+                "me.entry(ws)",
+                "",
+            ]
+        )
+    )
+
+    captured: dict[str, str] = {}
+
+    def fake_make_submit_handler(*, scheduler, cluster, resources, scheduling):
+        captured["scheduler"] = scheduler
+
+        class DummyHandler:
+            def __init__(self) -> None:
+                self.submitted_runs = []
+
+            def __call__(self, _script, mol_run, _exp_spec, _project_spec):
+                mol_run._update_metadata(
+                    executor_info={"backend": "molq", "scheduler": scheduler}
+                )
+                self.submitted_runs.append(mol_run)
+
+        return DummyHandler()
+
+    import molexp.plugins.submit_molq.metadata as metadata_mod
+    import molexp.plugins.submit_molq.submit as submit_mod
+
+    monkeypatch.setattr(metadata_mod, "supported_schedulers", lambda: ("local", "slurm"))
+    monkeypatch.setattr(submit_mod, "make_submit_handler", fake_make_submit_handler)
+
+    result = runner.invoke(app, ["run", str(script), "--scheduler", "local"])
+
+    assert result.exit_code == 0, result.output
+    assert captured["scheduler"] == "local"
+
+
+def test_run_cancel_uses_molq_job_id(monkeypatch, tmp_path):
+    workspace, experiment, run = _make_workspace(tmp_path)
+    run._update_metadata(
+        status="pending",
+        executor_info={
+            "backend": "molq",
+            "scheduler": "slurm",
+            "cluster_name": "default",
+            "job_id": "molq-job-123",
+            "scheduler_job_id": "sched-456",
+        },
+    )
+
+    calls: list[tuple[str, str, str]] = []
+
+    class FakeSubmitor:
+        def __init__(self, cluster_name: str, scheduler: str) -> None:
+            self.cluster_name = cluster_name
+            self.scheduler = scheduler
+
+        def cancel(self, job_id: str) -> None:
+            calls.append((self.cluster_name, self.scheduler, job_id))
+
+        def close(self) -> None:
+            return None
+
+    fake_molq = ModuleType("molq")
+    fake_molq.Submitor = FakeSubmitor
+    monkeypatch.setitem(sys.modules, "molq", fake_molq)
+
+    result = runner.invoke(
+        app,
+        ["runs", "cancel", run.id, "--path", str(workspace.root), "--yes"],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert calls == [("default", "slurm", "molq-job-123")]
+
+    reloaded = Workspace.load(workspace.root)
+    reloaded_run = reloaded.get_project("demo").get_experiment(experiment.id).get_run(run.id)
+    assert reloaded_run is not None
+    assert reloaded_run.status == "cancelled"
+
+
+def test_submit_handler_persists_executor_info(monkeypatch, tmp_path):
+    _workspace, _experiment, run = _make_workspace(tmp_path)
+    script = tmp_path / "train.py"
+    script.write_text("x = 1\n")
+
+    class DummyDuration:
+        @staticmethod
+        def parse(value: str) -> str:
+            return f"duration:{value}"
+
+    class DummyMemory:
+        @staticmethod
+        def parse(value: str) -> str:
+            return f"memory:{value}"
+
+    class DummyJobResources:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+    class DummyJobScheduling:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+    class DummyJobExecution:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+    class DummySubmitor:
+        def __init__(self, cluster_name: str, scheduler: str) -> None:
+            self.cluster_name = cluster_name
+            self.scheduler = scheduler
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+        def submit(self, **_kwargs):
+            return (
+                SimpleNamespace(job_id="molq-job-123", scheduler_job_id="sched-456"),
+                (),
+            )
+
+    fake_molq = ModuleType("molq")
+    fake_molq.Duration = DummyDuration
+    fake_molq.JobExecution = DummyJobExecution
+    fake_molq.JobResources = DummyJobResources
+    fake_molq.JobScheduling = DummyJobScheduling
+    fake_molq.Memory = DummyMemory
+    fake_molq.Submitor = DummySubmitor
+    monkeypatch.setitem(sys.modules, "molq", fake_molq)
+
+    handler = make_submit_handler(
+        scheduler="slurm",
+        cluster="cluster-a",
+        resources={"cpus": 4, "mem": "8G", "time": "1h"},
+        scheduling={"queue": "cpu"},
+    )
+    handler(
+        script,
+        run,
+        SimpleNamespace(),
+        SimpleNamespace(name="demo"),
+    )
+
+    assert run.metadata.executor_info == {
+        "backend": "molq",
+        "scheduler": "slurm",
+        "cluster_name": "cluster-a",
+        "job_id": "molq-job-123",
+        "scheduler_job_id": "sched-456",
+    }
diff --git a/tests/test_cli_run.py b/tests/test_cli_run.py
new file mode 100644
index 00000000..cf79d6db
--- /dev/null
+++ b/tests/test_cli_run.py
@@ -0,0 +1,216 @@
+"""CLI tests for `molexp run` --config / --profile behavior."""
+
+from __future__ import annotations
+
+import json
+
+from typer.testing import CliRunner
+
+from molexp.cli import app
+from molexp.workspace import Workspace
+
+runner = CliRunner()
+
+
+def _write_script(
+    path,
+    workspace_root,
+    body="ctx.set_result('epochs', ctx.config.get('epochs', 'default'))",
+):
+    path.write_text(
+        "\n".join(
+            [
+                "import molexp as me",
+                "",
+                f"ws = me.Workspace({str(workspace_root)!r})",
+                "project = ws.project('demo')",
+                "exp = project.experiment('train')",
+                "",
+                "def train(ctx: me.RunContext) -> None:",
+                f"    {body}",
+                "",
+                "exp.set_workflow(train)",
+                "me.entry(ws)",
+                "",
+            ]
+        )
+    )
+
+
+def _write_molcfg(path):
+    path.write_text(
+        "defaults:\n"
+        "  epochs: 100\n"
+        "  dataset: md17\n"
+        "profiles:\n"
+        "  dry-run:\n"
+        "    epochs: 1\n"
+        "    skip_heavy: true\n"
+        "  smoke:\n"
+        "    epochs: 5\n"
+    )
+
+
+class TestRunCommand:
+    def test_profile_executes_workflow_and_persists_metadata(self, tmp_path):
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        molcfg = tmp_path / "molcfg.yaml"
+        _write_molcfg(molcfg)
+        _write_script(script, workspace_root)
+
+        result = runner.invoke(
+            app,
+            ["run", str(script), "--config", str(molcfg), "--profile", "dry-run"],
+        )
+        assert result.exit_code == 0, result.output
+
+        ws = Workspace.load(workspace_root)
+        runs = ws.get_project("demo").get_experiment("train").list_runs()
+        assert len(runs) == 1
+
+        run = runs[0]
+        # profile name normalized
+        assert run.metadata.profile == "dry_run"
+        # defaults were merged into config
+        assert run.metadata.config["epochs"] == 1
+        assert run.metadata.config["dataset"] == "md17"
+        # content hash present
+        assert run.metadata.config_hash is not None
+        # run succeeded (profile is orthogonal to status)
+        assert run.status == "succeeded"
+
+        run_json = json.loads((run.run_dir / "run.json").read_text())
+        assert run_json["context"]["results"]["epochs"] == 1
+
+    def test_resume_replays_non_succeeded_runs_of_same_profile(self, tmp_path):
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        molcfg = tmp_path / "molcfg.yaml"
+        _write_molcfg(molcfg)
+        _write_script(
+            script,
+            workspace_root,
+            body=(
+                "import pathlib, os\n"
+                "    marker = pathlib.Path(ctx.run.run_dir) / 'fail_once'\n"
+                "    if not marker.exists():\n"
+                "        marker.touch()\n"
+                "        raise RuntimeError('boom')\n"
+                "    ctx.set_result('epochs', ctx.config['epochs'])"
+            ),
+        )
+
+        # First run: fails
+        result = runner.invoke(
+            app, ["run", str(script), "--config", str(molcfg), "--profile", "smoke"]
+        )
+        ws = Workspace.load(workspace_root)
+        runs = ws.get_project("demo").get_experiment("train").list_runs()
+        assert len(runs) == 1
+        assert runs[0].status == "failed"
+        assert runs[0].metadata.profile == "smoke"
+
+        # Resume: re-executes the failed run because profile matches
+        result = runner.invoke(
+            app,
+            [
+                "run",
+                str(script),
+                "--config",
+                str(molcfg),
+                "--profile",
+                "smoke",
+                "--resume",
+            ],
+        )
+        assert result.exit_code == 0, result.output
+
+        ws = Workspace.load(workspace_root)
+        runs = ws.get_project("demo").get_experiment("train").list_runs()
+        assert len(runs) == 1
+        assert runs[0].status == "succeeded"
+
+    def test_succeeded_runs_are_skipped_by_default(self, tmp_path):
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        molcfg = tmp_path / "molcfg.yaml"
+        _write_molcfg(molcfg)
+        _write_script(script, workspace_root, body="ctx.set_result('mode', 'wet')")
+
+        # First run succeeds
+        result = runner.invoke(
+            app, ["run", str(script), "--config", str(molcfg), "--profile", "smoke"]
+        )
+        assert result.exit_code == 0, result.output
+
+        # Second run: same profile — skipped because already succeeded
+        result = runner.invoke(
+            app, ["run", str(script), "--config", str(molcfg), "--profile", "smoke"]
+        )
+        assert result.exit_code == 0, result.output
+        assert "skipped" in result.output
+
+    def test_different_profiles_produce_different_runs(self, tmp_path):
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        molcfg = tmp_path / "molcfg.yaml"
+        _write_molcfg(molcfg)
+        _write_script(script, workspace_root)
+
+        result = runner.invoke(
+            app, ["run", str(script), "--config", str(molcfg), "--profile", "dry-run"]
+        )
+        assert result.exit_code == 0, result.output
+
+        result = runner.invoke(
+            app, ["run", str(script), "--config", str(molcfg), "--profile", "smoke"]
+        )
+        assert result.exit_code == 0, result.output
+
+        ws = Workspace.load(workspace_root)
+        runs = ws.get_project("demo").get_experiment("train").list_runs()
+        # Two distinct runs, one per profile
+        assert len(runs) == 2
+        profiles = {r.metadata.profile for r in runs}
+        assert profiles == {"dry_run", "smoke"}
+
+    def test_unknown_profile_reports_error(self, tmp_path):
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        molcfg = tmp_path / "molcfg.yaml"
+        _write_molcfg(molcfg)
+        _write_script(script, workspace_root)
+
+        result = runner.invoke(
+            app, ["run", str(script), "--config", str(molcfg), "--profile", "missing"]
+        )
+        assert result.exit_code == 1
+        assert "Unknown profile" in result.output
+
+    def test_profile_without_config_aborts(self, tmp_path):
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        _write_script(script, workspace_root)
+
+        # No molcfg.yaml in CWD and no --config
+        result = runner.invoke(
+            app, ["run", str(script), "--profile", "dry-run"]
+        )
+        assert result.exit_code == 1
+        assert "no config file" in result.output.lower()
+
+    def test_run_help_shows_backends(self):
+        result = runner.invoke(app, ["run", "--help"])
+        assert result.exit_code == 0
+        assert "local" in result.output
+
+    def test_run_help_has_grouped_options(self):
+        result = runner.invoke(app, ["run", "--help"])
+        assert result.exit_code == 0
+        assert "--local" in result.output
+        assert "--scheduler" in result.output
+        assert "--slurm" in result.output
+        assert "--profile" in result.output
+        assert "--config" in result.output
+        assert "HPC Options" in result.output
diff --git a/tests/test_cli_run_jobs.py b/tests/test_cli_run_jobs.py
new file mode 100644
index 00000000..4639a0ea
--- /dev/null
+++ b/tests/test_cli_run_jobs.py
@@ -0,0 +1,169 @@
+"""CLI tests for ``molexp run -j/--jobs N`` — local sweep-level parallelism.
+
+Phase-1 surface (see ``docs/spec/unified-pydantic-graph-dispatch.md``).
+"""
+
+from __future__ import annotations
+
+import time
+
+from typer.testing import CliRunner
+
+from molexp.cli import app
+from molexp.workspace import Workspace
+
+runner = CliRunner()
+
+
+def _write_parallel_script(path, workspace_root, n_experiments: int, sleep_s: float) -> None:
+    """Write a script with *n_experiments* each sleeping *sleep_s* seconds."""
+    path.write_text(
+        "\n".join(
+            [
+                "import time",
+                "import molexp as me",
+                "",
+                f"ws = me.Workspace({str(workspace_root)!r})",
+                "project = ws.project('demo')",
+                "",
+                "def sleeper(ctx):",
+                f"    time.sleep({sleep_s})",
+                "    ctx.set_result('done', True)",
+                "",
+                f"for i in range({n_experiments}):",
+                "    exp = project.experiment(f'exp{i}')",
+                "    exp.set_workflow(sleeper)",
+                "",
+                "me.entry(ws)",
+                "",
+            ]
+        )
+    )
+
+
+class TestJobsFlag:
+    def test_help_lists_jobs_option(self):
+        result = runner.invoke(app, ["run", "--help"])
+        assert result.exit_code == 0
+        assert "--jobs" in result.output or "-j" in result.output
+
+    def test_jobs_gt_1_runs_experiments_in_parallel(self, tmp_path):
+        """Three experiments × 0.3s should finish in roughly 0.3s with ``-j 3``."""
+        sleep_s = 0.3
+        n = 3
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        _write_parallel_script(script, workspace_root, n_experiments=n, sleep_s=sleep_s)
+
+        t0 = time.perf_counter()
+        result = runner.invoke(app, ["run", str(script), "--local", "-j", str(n)])
+        wall = time.perf_counter() - t0
+
+        assert result.exit_code == 0, result.output
+        # Parallel wall time should be < 2× single-experiment time.
+        # Sequential would be n * sleep_s = 0.9s; parallel ~= sleep_s + overhead.
+        assert wall < 2 * sleep_s * n * 0.7, (
+            f"Expected parallel execution (~{sleep_s}s), got {wall:.2f}s — "
+            "probably fell back to sequential."
+        )
+
+        ws = Workspace.load(workspace_root)
+        all_runs = [
+            run
+            for exp in ws.get_project("demo").list_experiments()
+            for run in exp.list_runs()
+        ]
+        assert len(all_runs) == n
+        for run in all_runs:
+            assert run.status == "succeeded"
+
+    def test_jobs_1_is_sequential(self, tmp_path):
+        """Three experiments × 0.3s with ``-j 1`` must take ~0.9s (strict serial)."""
+        sleep_s = 0.3
+        n = 3
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        _write_parallel_script(script, workspace_root, n_experiments=n, sleep_s=sleep_s)
+
+        t0 = time.perf_counter()
+        result = runner.invoke(app, ["run", str(script), "--local", "-j", "1"])
+        wall = time.perf_counter() - t0
+
+        assert result.exit_code == 0, result.output
+        # With n experiments × sleep_s each, serial wall time >= n * sleep_s * 0.9.
+        assert wall >= n * sleep_s * 0.9, (
+            f"Expected serial execution (~{n * sleep_s}s), got {wall:.2f}s — "
+            "concurrency leaked through."
+        )
+
+    def test_jobs_default_is_sequential(self, tmp_path):
+        """No ``-j`` flag → jobs=1 (backwards compatible with current behaviour)."""
+        sleep_s = 0.2
+        n = 3
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        _write_parallel_script(script, workspace_root, n_experiments=n, sleep_s=sleep_s)
+
+        t0 = time.perf_counter()
+        result = runner.invoke(app, ["run", str(script), "--local"])
+        wall = time.perf_counter() - t0
+
+        assert result.exit_code == 0, result.output
+        assert wall >= n * sleep_s * 0.9, (
+            f"Default should be sequential: expected ~{n * sleep_s}s, got {wall:.2f}s"
+        )
+
+    def test_jobs_from_profile(self, tmp_path):
+        """`jobs:` key in molcfg profile takes effect when CLI ``-j`` is omitted."""
+        sleep_s = 0.3
+        n = 3
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        molcfg = tmp_path / "molcfg.yaml"
+        _write_parallel_script(script, workspace_root, n_experiments=n, sleep_s=sleep_s)
+        molcfg.write_text(
+            "defaults: {}\n"
+            "profiles:\n"
+            "  fast:\n"
+            f"    jobs: {n}\n"
+        )
+
+        t0 = time.perf_counter()
+        result = runner.invoke(
+            app,
+            ["run", str(script), "--local", "--config", str(molcfg), "--profile", "fast"],
+        )
+        wall = time.perf_counter() - t0
+
+        assert result.exit_code == 0, result.output
+        assert wall < 2 * sleep_s * n * 0.7, (
+            f"Profile jobs={n} should parallelize, expected ~{sleep_s}s, got {wall:.2f}s"
+        )
+
+    def test_cli_jobs_overrides_profile(self, tmp_path):
+        """CLI ``-j 1`` beats profile ``jobs: 4``."""
+        sleep_s = 0.2
+        n = 3
+        workspace_root = tmp_path / "workspace"
+        script = tmp_path / "train.py"
+        molcfg = tmp_path / "molcfg.yaml"
+        _write_parallel_script(script, workspace_root, n_experiments=n, sleep_s=sleep_s)
+        molcfg.write_text(
+            "defaults: {}\n"
+            "profiles:\n"
+            "  loud:\n"
+            "    jobs: 4\n"
+        )
+
+        t0 = time.perf_counter()
+        result = runner.invoke(
+            app,
+            ["run", str(script), "--local", "-j", "1",
+             "--config", str(molcfg), "--profile", "loud"],
+        )
+        wall = time.perf_counter() - t0
+
+        assert result.exit_code == 0, result.output
+        assert wall >= n * sleep_s * 0.9, (
+            f"CLI -j 1 should override profile jobs=4; expected ~{n*sleep_s}s, got {wall:.2f}s"
+        )
diff --git a/tests/test_compute_integration.py b/tests/test_compute_integration.py
deleted file mode 100644
index 4c9d6321..00000000
--- a/tests/test_compute_integration.py
+++ /dev/null
@@ -1,136 +0,0 @@
-"""Integration tests for molpy.Compute classes in molexp workflows.
-
-This module tests that real molpy.Compute classes (MCD, PMSD) work seamlessly
-as molexp workflow tasks.
-"""
-
-import pytest
-import numpy as np
-from typing import Any
-
-from molexp.workflow import TaskProtocol, register_task
-
-
-# Skip if molpy is not available
-pytest.importorskip("molpy")
-
-from molpy.compute import MCDCompute, PMSDCompute
-from molpy.core import Frame
-from molpy.core.trajectory import Trajectory
-from molpy.core.box import Box
-
-
-
-
-class TestMCDComputeIntegration:
-    """Test MCDCompute as a workflow task."""
-    
-    def test_mcd_is_protocol_compatible(self):
-        """Test that MCDCompute implements TaskProtocol."""
-        mcd = MCDCompute(tags=["1"], max_dt=1.0, dt=0.1)
-        assert isinstance(mcd, TaskProtocol)
-    
-    def test_mcd_has_required_methods(self):
-        """Test that MCDCompute has execute() and dump() methods."""
-        mcd = MCDCompute(tags=["1"], max_dt=1.0, dt=0.1)
-        assert hasattr(mcd, "execute")
-        assert hasattr(mcd, "dump")
-        assert callable(mcd.execute)
-        assert callable(mcd.dump)
-    
-    def test_mcd_dump_with_com(self):
-        """Test serializing MCDCompute config with center_of_mass."""
-        com = {1: 1.008, 6: 12.011}
-        mcd = MCDCompute(tags=["1"], max_dt=10.0, dt=0.1, center_of_mass=com)
-        config = mcd.dump()
-        
-        assert config["center_of_mass"] == com
-    
-    def test_mcd_registration(self):
-        """Test registering MCDCompute is rejected (non-Pydantic config)."""
-        with pytest.raises(ValueError, match="config_type"):
-            register_task(MCDCompute)
-
-
-class TestPMSDComputeIntegration:
-    """Test PMSDCompute as a workflow task."""
-    
-    def test_pmsd_is_protocol_compatible(self):
-        """Test that PMSDCompute implements TaskProtocol."""
-        pmsd = PMSDCompute(cation_type=1, anion_type=2, max_dt=1.0, dt=0.1)
-        assert isinstance(pmsd, TaskProtocol)
-    
-    def test_pmsd_has_required_methods(self):
-        """Test that PMSDCompute has execute() and dump() methods."""
-        pmsd = PMSDCompute(cation_type=1, anion_type=2, max_dt=1.0, dt=0.1)
-        assert hasattr(pmsd, "execute")
-        assert hasattr(pmsd, "dump")
-        assert callable(pmsd.execute)
-        assert callable(pmsd.dump)
-    
-    def test_pmsd_dump(self):
-        """Test serializing PMSDCompute config."""
-        pmsd = PMSDCompute(cation_type=1, anion_type=2, max_dt=30.0, dt=0.01)
-        config = pmsd.dump()
-        
-        assert config == {
-            "cation_type": 1,
-            "anion_type": 2,
-            "max_dt": 30.0,
-            "dt": 0.01,
-        }
-    
-    def test_pmsd_registration(self):
-        """Test registering PMSDCompute is rejected (non-Pydantic config)."""
-        with pytest.raises(ValueError, match="config_type"):
-            register_task(PMSDCompute)
-
-
-class TestComputeInWorkflow:
-    """Test using Compute classes in actual workflows."""
-    
-    def test_compute_error_handling(self):
-        """Test error handling when input is missing."""
-        mcd = MCDCompute(tags=["1"], max_dt=1.0, dt=0.1)
-        
-        with pytest.raises(ValueError, match="Missing required input: input"):
-            mcd.execute(wrong_key="value")
-
-
-class TestComputeConfigRoundtrip:
-    """Test config serialization and reconstruction."""
-    
-    def test_mcd_config_roundtrip(self):
-        """Test that MCDCompute config can be dumped and reconstructed."""
-        # Create original
-        mcd1 = MCDCompute(tags=["1", "2"], max_dt=30.0, dt=0.01)
-        
-        # Dump config
-        config = mcd1.dump()
-        
-        # Reconstruct
-        mcd2 = MCDCompute(**config)
-        
-        # Verify they have same config
-        assert mcd2.dump() == config
-        assert mcd2.tags == mcd1.tags
-        assert mcd2.max_dt == mcd1.max_dt
-        assert mcd2.dt == mcd1.dt
-    
-    def test_pmsd_config_roundtrip(self):
-        """Test that PMSDCompute config can be dumped and reconstructed."""
-        # Create original
-        pmsd1 = PMSDCompute(cation_type=1, anion_type=2, max_dt=20.0, dt=0.05)
-        
-        # Dump config
-        config = pmsd1.dump()
-        
-        # Reconstruct
-        pmsd2 = PMSDCompute(**config)
-        
-        # Verify they have same config
-        assert pmsd2.dump() == config
-        assert pmsd2.cation_type == pmsd1.cation_type
-        assert pmsd2.anion_type == pmsd1.anion_type
-        assert pmsd2.max_dt == pmsd1.max_dt
-        assert pmsd2.dt == pmsd1.dt
diff --git a/tests/test_config/__init__.py b/tests/test_config/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_config/test_loader.py b/tests/test_config/test_loader.py
new file mode 100644
index 00000000..79bc7e5f
--- /dev/null
+++ b/tests/test_config/test_loader.py
@@ -0,0 +1,77 @@
+"""Tests for molexp.config.loader."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from molexp.config import load_molcfg
+from molexp.config.loader import find_default_config
+
+
+YAML_SAMPLE = """\
+version: 1
+defaults:
+  dataset: md17
+  epochs: 100
+
+profiles:
+  dry-run:
+    extends: defaults
+    epochs: 1
+  smoke:
+    extends: defaults
+    epochs: 5
+"""
+
+
+class TestLoadMolCfg:
+    def test_load_yaml(self, tmp_path):
+        p = tmp_path / "molcfg.yaml"
+        p.write_text(YAML_SAMPLE)
+        cfg = load_molcfg(p)
+        assert cfg.defaults == {"dataset": "md17", "epochs": 100}
+        # dashes normalized at load
+        assert "dry_run" in cfg.profiles
+        resolved = cfg.resolve("dry-run")
+        assert resolved.name == "dry_run"
+        assert resolved["epochs"] == 1
+        assert resolved["dataset"] == "md17"
+
+    def test_load_json(self, tmp_path):
+        p = tmp_path / "molcfg.json"
+        p.write_text(
+            json.dumps(
+                {
+                    "defaults": {"x": 1},
+                    "profiles": {"quick": {"x": 2}},
+                }
+            )
+        )
+        cfg = load_molcfg(p)
+        assert cfg.resolve("quick")["x"] == 2
+
+    def test_missing_file(self, tmp_path):
+        with pytest.raises(FileNotFoundError):
+            load_molcfg(tmp_path / "no.yaml")
+
+    def test_unsupported_suffix(self, tmp_path):
+        p = tmp_path / "cfg.toml"
+        p.write_text("x = 1\n")
+        with pytest.raises(ValueError, match="Unsupported"):
+            load_molcfg(p)
+
+
+class TestFindDefault:
+    def test_finds_yaml(self, tmp_path):
+        (tmp_path / "molcfg.yaml").write_text("defaults: {}\n")
+        assert find_default_config(tmp_path) == tmp_path / "molcfg.yaml"
+
+    def test_returns_none_when_absent(self, tmp_path):
+        assert find_default_config(tmp_path) is None
+
+    def test_prefers_yaml_over_json(self, tmp_path):
+        (tmp_path / "molcfg.yaml").write_text("defaults: {}\n")
+        (tmp_path / "molcfg.json").write_text("{}")
+        assert find_default_config(tmp_path).name == "molcfg.yaml"
diff --git a/tests/test_config/test_models.py b/tests/test_config/test_models.py
new file mode 100644
index 00000000..2473f1f3
--- /dev/null
+++ b/tests/test_config/test_models.py
@@ -0,0 +1,128 @@
+"""Tests for molexp.config.models (ProfileConfig, MolCfg)."""
+
+from __future__ import annotations
+
+import pytest
+
+from molexp.config import MolCfg, ProfileConfig, normalize_profile_name
+
+
+class TestNormalization:
+    def test_dash_to_underscore(self):
+        assert normalize_profile_name("dry-run") == "dry_run"
+
+    def test_strips_whitespace(self):
+        assert normalize_profile_name("  smoke  ") == "smoke"
+
+    def test_preserves_case(self):
+        assert normalize_profile_name("Fast-Mode") == "Fast_Mode"
+
+
+class TestProfileConfig:
+    def test_mapping_access(self):
+        cfg = ProfileConfig({"epochs": 10, "dataset": "md17"}, name="dry_run")
+        assert cfg["epochs"] == 10
+        assert cfg.get("dataset") == "md17"
+        assert cfg.get("missing", "fallback") == "fallback"
+        assert "epochs" in cfg
+        assert len(cfg) == 2
+        assert set(cfg) == {"epochs", "dataset"}
+
+    def test_name_normalized_on_construction(self):
+        cfg = ProfileConfig({}, name="dry-run")
+        assert cfg.name == "dry_run"
+
+    def test_none_name(self):
+        cfg = ProfileConfig({"x": 1}, name=None)
+        assert cfg.name is None
+
+    def test_immutable(self):
+        data = {"x": 1}
+        cfg = ProfileConfig(data, name=None)
+        data["x"] = 999
+        assert cfg["x"] == 1  # deep-copied on construction
+
+    def test_content_hash_deterministic(self):
+        a = ProfileConfig({"x": 1, "y": 2}, name="a")
+        b = ProfileConfig({"y": 2, "x": 1}, name="b")  # different name & order
+        # hash ignores profile name and key order
+        assert a.content_hash() == b.content_hash()
+
+    def test_content_hash_changes_with_data(self):
+        a = ProfileConfig({"x": 1}, name=None)
+        b = ProfileConfig({"x": 2}, name=None)
+        assert a.content_hash() != b.content_hash()
+
+    def test_to_dict_returns_copy(self):
+        cfg = ProfileConfig({"x": {"y": 1}}, name=None)
+        d = cfg.to_dict()
+        d["x"]["y"] = 999
+        assert cfg["x"]["y"] == 1
+
+
+class TestMolCfgResolve:
+    def test_resolve_none_returns_defaults(self):
+        m = MolCfg(defaults={"epochs": 100, "dataset": "md17"})
+        cfg = m.resolve(None)
+        assert cfg.name is None
+        assert cfg["epochs"] == 100
+
+    def test_profile_overrides_defaults(self):
+        m = MolCfg(
+            defaults={"epochs": 100, "dataset": "md17"},
+            profiles={"dry_run": {"epochs": 1}},
+        )
+        cfg = m.resolve("dry_run")
+        assert cfg.name == "dry_run"
+        assert cfg["epochs"] == 1
+        assert cfg["dataset"] == "md17"  # inherited from defaults
+
+    def test_profile_name_dash_accepted(self):
+        m = MolCfg(profiles={"dry_run": {"x": 1}})
+        cfg = m.resolve("dry-run")  # CLI form
+        assert cfg.name == "dry_run"
+
+    def test_yaml_dash_key_normalized_at_load(self):
+        # Profile keys with dashes are normalized when the model is built
+        m = MolCfg.model_validate(
+            {"profiles": {"dry-run": {"epochs": 1}}}
+        )
+        assert "dry_run" in m.profiles
+        assert m.resolve("dry-run")["epochs"] == 1
+
+    def test_extends_chain(self):
+        m = MolCfg(
+            defaults={"epochs": 100, "batch_size": 32, "dataset": "md17"},
+            profiles={
+                "smoke": {"extends": "defaults", "epochs": 5},
+                "tiny_smoke": {"extends": "smoke", "batch_size": 4},
+            },
+        )
+        cfg = m.resolve("tiny_smoke")
+        assert cfg["epochs"] == 5       # from smoke
+        assert cfg["batch_size"] == 4   # overridden
+        assert cfg["dataset"] == "md17"  # from defaults
+
+    def test_unknown_profile_raises(self):
+        m = MolCfg(profiles={"smoke": {}})
+        with pytest.raises(KeyError, match="Unknown profile"):
+            m.resolve("missing")
+
+    def test_circular_extends_raises(self):
+        m = MolCfg(
+            profiles={
+                "a": {"extends": "b"},
+                "b": {"extends": "a"},
+            }
+        )
+        with pytest.raises(ValueError, match="Circular"):
+            m.resolve("a")
+
+    def test_deep_merge(self):
+        m = MolCfg(
+            defaults={"optim": {"lr": 0.001, "momentum": 0.9}},
+            profiles={"fast": {"optim": {"lr": 0.01}}},
+        )
+        cfg = m.resolve("fast")
+        # deep-merge preserves untouched nested keys
+        assert cfg["optim"] == {"lr": 0.01, "momentum": 0.9}
diff --git a/tests/test_entry.py b/tests/test_entry.py
new file mode 100644
index 00000000..6249f0cd
--- /dev/null
+++ b/tests/test_entry.py
@@ -0,0 +1,74 @@
+"""Tests for entry point registry."""
+
+import pytest
+
+from molexp.entry import _registry, clear_registry, entry, load_workspaces
+from molexp.workspace import Workspace
+
+
+@pytest.fixture(autouse=True)
+def clean_registry():
+    clear_registry()
+    yield
+    clear_registry()
+
+
+class TestEntry:
+    def test_entry_populates_registry(self, tmp_path):
+        ws = Workspace(tmp_path / "ws", name="ws")
+        entry(ws)
+        assert len(_registry) == 1
+        assert _registry[0] is ws
+
+    def test_multiple_entries(self, tmp_path):
+        a = Workspace(tmp_path / "a", name="a")
+        b = Workspace(tmp_path / "b", name="b")
+        entry(a)
+        entry(b)
+        assert len(_registry) == 2
+
+    def test_clear_registry(self, tmp_path):
+        entry(Workspace(tmp_path / "ws", name="ws"))
+        clear_registry()
+        assert len(_registry) == 0
+
+
+class TestLoadWorkspaces:
+    def test_load_from_script(self, tmp_path):
+        ws_path = tmp_path / "ws"
+        script = tmp_path / "test_script.py"
+        script.write_text(
+            "from molexp.workspace import Workspace\n"
+            "from molexp.entry import entry\n"
+            f"ws = Workspace({str(ws_path)!r}, name='from-script')\n"
+            "entry(ws)\n"
+        )
+        workspaces = load_workspaces(script)
+        assert len(workspaces) == 1
+        assert workspaces[0].name == "from-script"
+
+    def test_load_clears_previous_entries(self, tmp_path):
+        entry(Workspace(tmp_path / "stale", name="stale"))
+
+        ws_path = tmp_path / "fresh"
+        script = tmp_path / "test_script.py"
+        script.write_text(
+            "from molexp.workspace import Workspace\n"
+            "from molexp.entry import entry\n"
+            f"entry(Workspace({str(ws_path)!r}, name='fresh'))\n"
+        )
+        workspaces = load_workspaces(script)
+        assert len(workspaces) == 1
+        assert workspaces[0].name == "fresh"
+
+    def test_load_empty_script(self, tmp_path):
+        script = tmp_path / "empty.py"
+        script.write_text("x = 1\n")
+        workspaces = load_workspaces(script)
+        assert workspaces == []
+
+    def test_load_invalid_script(self, tmp_path):
+        script = tmp_path / "bad.py"
+        script.write_text("raise ImportError('boom')\n")
+        with pytest.raises(ImportError):
+            load_workspaces(script)
diff --git a/tests/test_experiment_spec.py b/tests/test_experiment_spec.py
new file mode 100644
index 00000000..9588df4b
--- /dev/null
+++ b/tests/test_experiment_spec.py
@@ -0,0 +1,133 @@
+"""Tests for Experiment workflow binding (previously the user-facing spec)."""
+
+import json
+
+import pytest
+
+from molexp.workflow.spec import WorkflowBuilder, WorkflowSpec
+from molexp.workspace import Workspace
+from molexp.workspace.experiment import _promote_to_workflow
+
+
+@pytest.fixture
+def workspace(tmp_path):
+    return Workspace(root=tmp_path / "lab", name="Test")
+
+
+@pytest.fixture
+def project(workspace):
+    return workspace.project("test-project")
+
+
+@pytest.fixture
+def experiment(project):
+    return project.experiment(
+        "test-experiment",
+        params={"lr": 1e-3},
+        n_replicas=2,
+    )
+
+
+class TestExperimentConstruction:
+    def test_stores_fields(self, project):
+        exp = project.experiment(
+            "sweep",
+            params={"x": 1},
+            n_replicas=3,
+        )
+        assert exp.name == "sweep"
+        assert exp.project is project
+        assert exp.n_replicas == 3
+
+    def test_default_values(self, project):
+        exp = project.experiment("minimal")
+        assert exp.params == {}
+        assert exp.n_replicas == 1
+        assert exp.description == ""
+        assert exp.tags == []
+        assert exp.seeds is None
+
+    def test_workflow_initially_none(self, experiment):
+        assert experiment.workflow is None
+
+
+class TestSetWorkflow:
+    def test_callable_promotes_to_workflow_spec(self, experiment):
+        def train(ctx):
+            pass
+
+        experiment.set_workflow(train)
+        assert isinstance(experiment.workflow, WorkflowSpec)
+
+    def test_workflow_spec_stored_directly(self, experiment):
+        spec = WorkflowBuilder(name="test").build()
+        experiment.set_workflow(spec)
+        assert experiment.workflow is spec
+
+    def test_workflow_always_workflow_spec_type(self, experiment):
+        def train(ctx):
+            pass
+
+        experiment.set_workflow(train)
+        assert type(experiment.workflow) is WorkflowSpec
+
+    def test_non_callable_raises_type_error(self, experiment):
+        with pytest.raises(TypeError, match="Expected WorkflowSpec or callable"):
+            experiment.set_workflow(42)
+
+    def test_double_set_raises_value_error(self, experiment):
+        experiment.set_workflow(lambda ctx: None)
+        with pytest.raises(ValueError, match="already has a workflow"):
+            experiment.set_workflow(lambda ctx: None)
+
+
+class TestGetSeeds:
+    def test_default_seeds(self, project):
+        exp = project.experiment("t1", n_replicas=3)
+        seeds = exp.get_seeds()
+        assert len(seeds) == 3
+        assert seeds[0] == 42
+
+    def test_explicit_seeds(self, project):
+        exp = project.experiment("t2", n_replicas=2, seeds=[100, 200, 300])
+        seeds = exp.get_seeds()
+        assert seeds == [100, 200]
+
+    def test_seeds_extended_when_short(self, project):
+        exp = project.experiment("t3", n_replicas=8)
+        seeds = exp.get_seeds()
+        assert len(seeds) == 8
+        assert len(set(seeds)) == 8
+
+
+class TestPromoteToWorkflow:
+    def test_creates_workflow_spec(self):
+        def my_func(ctx):
+            pass
+
+        spec = _promote_to_workflow(my_func, "test")
+        assert isinstance(spec, WorkflowSpec)
+        assert spec.name == "test"
+
+    @pytest.mark.asyncio
+    async def test_promoted_run_context_function_receives_profile_config(self, tmp_path):
+        from molexp.config import ProfileConfig
+
+        def train(ctx):
+            assert ctx.config.name == "dry_run"
+            assert ctx.config["skip_heavy"] is True
+            ctx.set_result("profile", ctx.config.name)
+
+        spec = _promote_to_workflow(train, "test")
+
+        ws = Workspace(root=tmp_path / "lab", name="Test Lab")
+        project = ws.project("demo")
+        experiment = project.experiment("runtime")
+        run = experiment.run(parameters={})
+
+        profile_cfg = ProfileConfig({"skip_heavy": True}, name="dry-run")
+        result = await spec.execute(run=run, profile_config=profile_cfg)
+
+        assert result.status == "completed"
+        run_json = json.loads((run.run_dir / "run.json").read_text())
+        assert run_json["context"]["results"]["profile"] == "dry_run"
diff --git a/tests/test_models.py b/tests/test_models.py
deleted file mode 100644
index 459ed89d..00000000
--- a/tests/test_models.py
+++ /dev/null
@@ -1,107 +0,0 @@
-"""Tests for core models."""
-
-from datetime import datetime
-
-import pytest
-
-from molexp.models import (Asset, AssetRef, AssetType, Experiment, Project,
-                           Run, RunStatus, WorkflowSnapshot, WorkflowTemplate)
-
-
-def test_project_validation():
-    """Test project model validation."""
-    project = Project(
-        id="test-project",
-        name="Test Project",
-        description="A test project",
-        owner="researcher",
-        tags=["test", "demo"],
-        created_at=datetime.now(),
-    )
-
-    assert project.id == "test-project"
-    assert project.name == "Test Project"
-    assert project.path == "projects/test-project"
-
-
-def test_id_validation():
-    """Test id validation rules."""
-    # Valid IDs
-    Project(id="valid-project", name="Valid", created_at=datetime.now())
-    Project(id="project123", name="Valid", created_at=datetime.now())
-
-    # Invalid IDs
-    with pytest.raises(ValueError):
-        Project(id="AB", name="Too short", created_at=datetime.now())
-
-    with pytest.raises(ValueError):
-        Project(
-            id="Invalid_Project", name="Underscore", created_at=datetime.now()
-        )
-
-    with pytest.raises(ValueError):
-        Project(id="Invalid Project", name="Space", created_at=datetime.now())
-
-
-def test_experiment_model():
-    """Test experiment model."""
-    experiment = Experiment(
-        id="exp-1",
-        id="test-project",
-        name="Experiment 1",
-        created_at=datetime.now(),
-        workflow_template=WorkflowTemplate(source="workflow.py"),
-        parameter_space={"param1": [1, 2, 3]},
-    )
-
-    assert experiment.id == "exp-1"
-    assert experiment.path == "projects/test-project/experiments/exp-1"
-
-
-def test_run_model():
-    """Test run model."""
-    run = Run(
-        id="20251129_183000_a3b2",
-        id="test-project",
-        id="exp-1",
-        created_at=datetime.now(),
-        status=RunStatus.PENDING,
-        parameters={"param1": 1},
-        workflow_snapshot=WorkflowSnapshot(workflow_file="workflow.py"),
-        working_dir="projects/test-project/experiments/exp-1/runs/20251129_183000_a3b2",
-    )
-
-    assert run.id == "20251129_183000_a3b2"
-    assert run.status == RunStatus.PENDING
-    assert (
-        run.path == "projects/test-project/experiments/exp-1/runs/20251129_183000_a3b2"
-    )
-
-
-def test_asset_model():
-    """Test asset model."""
-    asset = Asset(
-        asset_id="a3f2e8d9-4b1c-4e5f-9a2b-1c3d4e5f6a7b",
-        type=AssetType.STRUCTURE,
-        format="pdb",
-        created_at=datetime.now(),
-        size_bytes=1024,
-        content_hash="sha256:abc123",
-        files=[],
-    )
-
-    assert asset.asset_id == "a3f2e8d9-4b1c-4e5f-9a2b-1c3d4e5f6a7b"
-    assert asset.type == AssetType.STRUCTURE
-    assert asset.path == "assets/a3f2e8d9-4b1c-4e5f-9a2b-1c3d4e5f6a7b"
-
-
-def test_asset_ref_model():
-    """Test asset reference model."""
-    ref = AssetRef(
-        asset_id="a3f2e8d9-4b1c-4e5f-9a2b-1c3d4e5f6a7b",
-        role="input_structure",
-        producer_id="20251129_183000_a3b2",
-    )
-
-    assert ref.asset_id == "a3f2e8d9-4b1c-4e5f-9a2b-1c3d4e5f6a7b"
-    assert ref.role == "input_structure"
diff --git a/tests/test_plugins/__init__.py b/tests/test_plugins/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_plugins/test_registry.py b/tests/test_plugins/test_registry.py
new file mode 100644
index 00000000..8222fc60
--- /dev/null
+++ b/tests/test_plugins/test_registry.py
@@ -0,0 +1,66 @@
+"""Tests for plugin registry."""
+
+import pytest
+
+from molexp.plugins import (
+    Capability,
+    CapabilityNotAvailable,
+    PluginRegistry,
+    discover_ui_plugins,
+)
+
+
+class TestPluginRegistry:
+    def test_fresh_registry_agent_probed(self):
+        reg = PluginRegistry()
+        # Agent availability depends on pydantic-ai being installed
+        try:
+            import pydantic_ai  # noqa: F401
+            assert reg.is_available(Capability.AGENT)
+        except ImportError:
+            assert not reg.is_available(Capability.AGENT)
+
+    def test_unavailable_raises(self):
+        reg = PluginRegistry()
+        # Use a fresh registry with cleared caches to test the raise path
+        reg.reset()
+        # Monkey-patch to make AGENT unavailable
+        reg._unavailable.add(Capability.AGENT)
+        with pytest.raises(CapabilityNotAvailable):
+            reg.get(Capability.AGENT)
+
+    def test_agent_available_if_pydantic_ai_installed(self):
+        reg = PluginRegistry()
+        try:
+            import pydantic_ai  # noqa: F401
+            assert reg.is_available(Capability.AGENT)
+        except ImportError:
+            assert not reg.is_available(Capability.AGENT)
+
+    def test_reset_clears_caches(self):
+        reg = PluginRegistry()
+        reg.is_available(Capability.AGENT)  # caches result
+        reg.reset()
+        assert len(reg._cache) == 0
+        assert len(reg._unavailable) == 0
+
+    def test_available_capabilities_returns_list(self):
+        reg = PluginRegistry()
+        caps = reg.available_capabilities()
+        assert isinstance(caps, list)
+
+    def test_capability_enum_values(self):
+        assert Capability.AGENT == "agent"
+
+    def test_discover_ui_plugins_always_includes_core(self):
+        plugins = discover_ui_plugins()
+        assert [plugin.id for plugin in plugins][0] == "core"
+
+    def test_discover_ui_plugins_includes_molq_when_supported(self, monkeypatch):
+        monkeypatch.setattr("molexp.plugins.supported_schedulers", lambda: ("slurm", "pbs"))
+
+        plugins = discover_ui_plugins()
+        molq = next(plugin for plugin in plugins if plugin.id == "molq")
+
+        assert molq.ui_module == "molq"
+        assert molq.metadata == {"schedulers": ["slurm", "pbs"]}
diff --git a/tests/test_protocol_integration.py b/tests/test_protocol_integration.py
deleted file mode 100644
index 64595b39..00000000
--- a/tests/test_protocol_integration.py
+++ /dev/null
@@ -1,265 +0,0 @@
-"""Tests for protocol interface and strict registry enforcement."""
-
-import pytest
-from typing import Any
-
-from molexp.workflow import TaskProtocol, Task, register_task, get_task_class, get_task_id
-
-
-# Test fixtures: Mock Compute class (simulating molpy.Compute)
-class MockCompute:
-    """Mock Compute class that implements TaskProtocol without inheriting from Task."""
-    
-    input_key: str = "input"
-    output_key: str = "result"
-    
-    def __init__(self, param1: str, param2: int, **config_kwargs: Any):
-        self._config = {"param1": param1, "param2": param2, **config_kwargs}
-        self.param1 = param1
-        self.param2 = param2
-    
-    def execute(self, ctx: Any | None = None, **inputs: Any) -> dict[str, Any]:
-        """Execute as workflow task."""
-        input_value = inputs.get(self.input_key)
-        if input_value is None:
-            raise ValueError(f"Missing required input: {self.input_key}")
-        
-        result = self._compute(input_value)
-        return {self.output_key: result}
-    
-    def _compute(self, input_value: Any) -> Any:
-        """Core computation logic."""
-        return f"{self.param1}_{input_value}_{self.param2}"
-    
-    def dump(self) -> dict[str, Any]:
-        """Serialize configuration."""
-        return self._config.copy()
-
-
-class TestProtocolCompatibility:
-    """Test TaskProtocol structural typing."""
-    
-    def test_protocol_instance_check(self):
-        """Test that MockCompute is recognized as TaskProtocol."""
-        compute = MockCompute(param1="test", param2=42)
-        assert isinstance(compute, TaskProtocol)
-    
-    def test_protocol_missing_execute(self):
-        """Test that class without execute() is not TaskProtocol."""
-        class BadCompute:
-            def dump(self) -> dict[str, Any]:
-                return {}
-        
-        bad = BadCompute()
-        assert not isinstance(bad, TaskProtocol)
-    
-    def test_protocol_missing_dump(self):
-        """Test that class without dump() is not TaskProtocol."""
-        class BadCompute:
-            def execute(self, ctx=None, **inputs: Any) -> dict[str, Any]:
-                return {}
-        
-        bad = BadCompute()
-        assert not isinstance(bad, TaskProtocol)
-
-
-class TestComputeAsTask:
-    """Test using Compute classes as workflow tasks."""
-    
-    def test_compute_execute(self):
-        """Test executing Compute via execute() method."""
-        compute = MockCompute(param1="hello", param2=99)
-        result = compute.execute(input="world")
-        
-        assert result == {"result": "hello_world_99"}
-    
-    def test_compute_dump(self):
-        """Test serializing Compute config."""
-        compute = MockCompute(param1="test", param2=42)
-        config = compute.dump()
-        
-        assert config == {"param1": "test", "param2": 42}
-    
-    def test_compute_custom_keys(self):
-        """Test Compute with custom input/output keys."""
-        class CustomCompute(MockCompute):
-            input_key = "data"
-            output_key = "output"
-        
-        compute = CustomCompute(param1="custom", param2=1)
-        result = compute.execute(data="test")
-        
-        assert result == {"output": "custom_test_1"}
-    
-    def test_compute_missing_input(self):
-        """Test error when required input is missing."""
-        compute = MockCompute(param1="test", param2=1)
-        
-        with pytest.raises(ValueError, match="Missing required input: input"):
-            compute.execute(wrong_key="value")
-
-
-class TestTaskConfigTypes:
-    """Test Task with Pydantic-only config types."""
-
-    def test_task_with_non_pydantic_config_rejected(self):
-        """Task must enforce Pydantic BaseModel configs."""
-        class BadConfig:
-            pass
-
-        class BadTask(Task[BadConfig, dict]):
-            config_type = BadConfig
-
-            def execute(self, ctx=None, **inputs: Any) -> dict[str, Any]:
-                return {"result": "bad"}
-
-        with pytest.raises(ValueError, match="config_type must be a Pydantic BaseModel"):
-            BadTask()
-
-
-class TestRegistration:
-    """Test registering protocol-compatible classes."""
-    
-    def test_register_compute_class(self):
-        """Test registering a non-Task class is rejected."""
-        with pytest.raises(ValueError, match="config_type"):
-            register_task(MockCompute)
-
-    def test_register_class_without_execute(self):
-        """Test that registering class without execute() raises error."""
-        class BadTask:
-            def dump(self) -> dict[str, Any]:
-                return {}
-
-        with pytest.raises(ValueError, match="config_type"):
-            register_task(BadTask)
-
-    def test_register_class_without_dump(self):
-        """Test that registering class without dump() raises error."""
-        class BadTask:
-            def execute(self, ctx=None, **inputs: Any) -> dict[str, Any]:
-                return {}
-
-        with pytest.raises(ValueError, match="config_type"):
-            register_task(BadTask)
-
-    def test_register_task_with_deterministic_id(self):
-        """Test deterministic task ID derivation for Task classes."""
-        from pydantic import BaseModel
-
-        class MyConfig(BaseModel):
-            value: int = 1
-
-        class MyTask(Task[MyConfig, dict]):
-            config_type = MyConfig
-
-            def execute(self, ctx=None, **inputs: Any) -> dict[str, Any]:
-                return {"result": self.config.value}
-
-        task_type_id = register_task(MyTask)
-        assert task_type_id == f"{MyTask.__module__}.{MyTask.__qualname__}"
-        assert get_task_id(MyTask) == task_type_id
-        assert get_task_class(task_type_id) is MyTask
-
-
-class TestMixedWorkflow:
-    """Test workflows mixing Pydantic Tasks and Compute tasks."""
-    
-    def test_mixed_task_types(self):
-        """Test that Pydantic Tasks execute as expected."""
-        from pydantic import BaseModel
-        
-        # Pydantic-based Task
-        class PydanticConfig(BaseModel):
-            multiplier: int
-        
-        class PydanticTask(Task[PydanticConfig, dict]):
-            config_type = PydanticConfig
-            
-            def execute(self, ctx=None, **inputs: Any) -> dict[str, Any]:
-                value = inputs.get("value", 1)
-                return {"result": value * self.config.multiplier}
-        
-        # Create instances
-        pydantic_task = PydanticTask(multiplier=2)
-        # Should be TaskProtocol
-        assert isinstance(pydantic_task, TaskProtocol)
-
-        # Should execute
-        result1 = pydantic_task.execute(value=5)
-        assert result1 == {"result": 10}
-
-        # Should dump
-        config1 = pydantic_task.dump()
-        assert config1 == {"multiplier": 2}
-
-
-class TestConfigSerialization:
-    """Test config serialization for Pydantic-only configs."""
-    
-    def test_pydantic_dump(self):
-        """Test dumping Pydantic config."""
-        from pydantic import BaseModel
-        
-        class Config(BaseModel):
-            name: str
-            value: int
-        
-        class MyTask(Task[Config, dict]):
-            config_type = Config
-            
-            def execute(self, ctx=None, **inputs: Any) -> dict[str, Any]:
-                return {}
-        
-        task = MyTask(name="test", value=42)
-        dumped = task.dump()
-        
-        assert dumped == {"name": "test", "value": 42}
-    
-    def test_dump_rejects_non_pydantic(self):
-        """Non-Pydantic configs should be rejected at construction."""
-        class BadConfig:
-            pass
-
-        class BadTask(Task[BadConfig, dict]):
-            config_type = BadConfig
-
-            def execute(self, ctx=None, **inputs: Any) -> dict[str, Any]:
-                return {}
-
-        with pytest.raises(ValueError, match="config_type must be a Pydantic BaseModel"):
-            BadTask()
-
-
-class TestErrorHandling:
-    """Test error handling and validation."""
-    
-    def test_pydantic_validation_error(self):
-        """Test that Pydantic validation errors are caught."""
-        from pydantic import BaseModel
-        
-        class Config(BaseModel):
-            value: int
-        
-        class MyTask(Task[Config, dict]):
-            config_type = Config
-            
-            def execute(self, ctx=None, **inputs: Any) -> dict[str, Any]:
-                return {}
-        
-        with pytest.raises(ValueError, match="Invalid Pydantic config"):
-            MyTask(value="not_an_int")
-    
-    def test_non_pydantic_config_rejected(self):
-        """Non-Pydantic configs are rejected before execution."""
-        class BadConfig:
-            value: int
-
-        class MyTask(Task[BadConfig, dict]):
-            config_type = BadConfig
-
-            def execute(self, ctx=None, **inputs: Any) -> dict[str, Any]:
-                return {}
-
-        with pytest.raises(ValueError, match="config_type must be a Pydantic BaseModel"):
-            MyTask(value=1)
diff --git a/tests/test_refactor_workflow_separation.py b/tests/test_refactor_workflow_separation.py
deleted file mode 100644
index bc2c5c3a..00000000
--- a/tests/test_refactor_workflow_separation.py
+++ /dev/null
@@ -1,448 +0,0 @@
-"""Tests for the workflow separation refactor.
-
-Covers:
-- TaskConfig.phase + engine phase filtering
-- MapTask execute
-- RunContext.from_run_dir + lazy resolution
-- RunContext.get_asset / find_asset
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-import pytest
-from pydantic import BaseModel
-
-from molexp.workflow.engine import WorkflowEngine
-from molexp.workflow.link import Link
-from molexp.workflow.task import Task, TaskConfig
-from molexp.workflow.registry import register_task
-from molexp.workflow.workflow import Workflow
-from molexp.workflow.control.map import MapTask, MapConfig
-from molexp.workspace import Workspace, RunContext
-
-
-# ============================================================================
-# Helpers
-# ============================================================================
-
-
-def _make_hierarchy(tmp_path):
-    workspace = Workspace(root=tmp_path / "workspace", name="Test")
-    workspace.materialize()
-    project = workspace.create_project(name="Project")
-    experiment = project.create_experiment(name="Experiment")
-    return workspace, project, experiment
-
-
-def _make_run(tmp_path, parameters=None):
-    _, _, experiment = _make_hierarchy(tmp_path)
-    return experiment.create_run(parameters=parameters or {})
-
-
-# ============================================================================
-# Phase filtering tests (tasks.md 1.x)
-# ============================================================================
-
-
-class PhaseConfig(BaseModel):
-    label: str = ""
-
-
-class PhaseTaskA(Task[PhaseConfig, dict]):
-    config_type = PhaseConfig
-    inputs = {}
-    outputs = {"value": int}
-
-    def execute(self, ctx=None, **inputs):
-        return {"value": 1}
-
-
-class PhaseTaskB(Task[PhaseConfig, dict]):
-    config_type = PhaseConfig
-    inputs = {"value": int}
-    outputs = {"result": int}
-
-    def execute(self, ctx=None, **inputs):
-        return {"result": inputs["value"] * 10}
-
-
-register_task(PhaseTaskA)
-register_task(PhaseTaskB)
-
-
-def test_taskconfig_phase_field():
-    tc = TaskConfig(task_id="t1", task_type="foo", config={}, phase="setup")
-    assert tc.phase == "setup"
-
-    tc_none = TaskConfig(task_id="t2", task_type="foo", config={})
-    assert tc_none.phase is None
-
-
-def test_phase_filtering_single_phase(tmp_path):
-    """Only tasks matching the requested phase (+ phase=None) should run."""
-    task_a = PhaseTaskA(label="a")
-    task_a.phase = "setup"
-    task_b = PhaseTaskB(label="b")
-    task_b.phase = "compute"
-
-    workflow = Workflow.from_tasks(
-        tasks=[task_a, task_b],
-        links=[
-            Link(
-                source=task_a.task_id,
-                target=task_b.task_id,
-                mapping={"value": "value"},
-            )
-        ],
-    )
-
-    run = _make_run(tmp_path)
-    with run.start() as ctx:
-        results = WorkflowEngine(workflow).execute(ctx, phases=["setup"])
-
-    # Only task_a should have executed
-    assert task_a.task_id in results
-    assert task_b.task_id not in results
-
-
-def test_no_phase_runs_all(tmp_path):
-    """When phases=None, all tasks run."""
-    task_a = PhaseTaskA(label="a")
-    task_a.phase = "setup"
-    task_b = PhaseTaskB(label="b")
-    task_b.phase = "compute"
-
-    workflow = Workflow.from_tasks(
-        tasks=[task_a, task_b],
-        links=[
-            Link(
-                source=task_a.task_id,
-                target=task_b.task_id,
-                mapping={"value": "value"},
-            )
-        ],
-    )
-
-    run = _make_run(tmp_path)
-    with run.start() as ctx:
-        results = WorkflowEngine(workflow).execute(ctx, phases=None)
-
-    assert task_a.task_id in results
-    assert task_b.task_id in results
-    assert results[task_b.task_id]["result"] == 10
-
-
-def test_cross_phase_persisted_results(tmp_path):
-    """Phase 2 can read results persisted by phase 1 from run.json."""
-    task_a = PhaseTaskA(label="a")
-    task_a.phase = "setup"
-    task_b = PhaseTaskB(label="b")
-    task_b.phase = "compute"
-
-    workflow = Workflow.from_tasks(
-        tasks=[task_a, task_b],
-        links=[
-            Link(
-                source=task_a.task_id,
-                target=task_b.task_id,
-                mapping={"value": "value"},
-            )
-        ],
-    )
-
-    run = _make_run(tmp_path)
-
-    # Phase 1: run setup
-    with run.start() as ctx:
-        WorkflowEngine(workflow).execute(ctx, phases=["setup"])
-
-    # Phase 2: run compute (should pick up task_a results from run.json)
-    with run.start() as ctx:
-        results = WorkflowEngine(workflow).execute(ctx, phases=["compute"])
-
-    assert task_b.task_id in results
-    assert results[task_b.task_id]["result"] == 10
-
-
-def test_class_level_phase_declaration(tmp_path):
-    """Tasks can declare phase at class level."""
-
-    class SetupTask(Task[PhaseConfig, dict]):
-        config_type = PhaseConfig
-        inputs = {}
-        outputs = {"value": int}
-        phase = "setup"  # Class-level declaration
-
-        def execute(self, ctx=None, **inputs):
-            return {"value": 42}
-
-    class ComputeTask(Task[PhaseConfig, dict]):
-        config_type = PhaseConfig
-        inputs = {"value": int}
-        outputs = {"result": int}
-        phase = "compute"  # Class-level declaration
-
-        def execute(self, ctx=None, **inputs):
-            return {"result": inputs["value"] * 2}
-
-    register_task(SetupTask)
-    register_task(ComputeTask)
-
-    task_a = SetupTask(label="setup")
-    task_b = ComputeTask(label="compute")
-
-    workflow = Workflow.from_tasks(
-        tasks=[task_a, task_b],
-        links=[
-            Link(
-                source=task_a.task_id,
-                target=task_b.task_id,
-                mapping={"value": "value"},
-            )
-        ],
-    )
-
-    run = _make_run(tmp_path)
-    with run.start() as ctx:
-        results = WorkflowEngine(workflow).execute(ctx, phases=["setup"])
-
-    # Only setup task should execute
-    assert task_a.task_id in results
-    assert task_b.task_id not in results
-    assert results[task_a.task_id]["value"] == 42
-
-
-def test_instance_phase_overrides_class_phase():
-    """Instance-level phase assignment overrides class-level default."""
-
-    class DefaultPhaseTask(Task[PhaseConfig, dict]):
-        config_type = PhaseConfig
-        inputs = {}
-        outputs = {"value": int}
-        phase = "default"  # Class-level default
-
-        def execute(self, ctx=None, **inputs):
-            return {"value": 100}
-
-    register_task(DefaultPhaseTask)
-
-    task = DefaultPhaseTask(label="test")
-    assert task.phase == "default"  # Initially has class-level phase
-
-    task.phase = "custom"  # Instance override
-    assert task.phase == "custom"  # Now has instance-level phase
-
-    workflow = Workflow.from_tasks(tasks=[task], links=[])
-
-    # Verify TaskConfig has the overridden phase
-    assert workflow.task_configs[0].phase == "custom"
-
-
-def test_phase_inheritance():
-    """Subclass inherits parent's phase if not overridden."""
-
-    class BasePhaseTask(Task[PhaseConfig, dict]):
-        config_type = PhaseConfig
-        inputs = {}
-        outputs = {"value": int}
-        phase = "inherited"
-
-        def execute(self, ctx=None, **inputs):
-            return {"value": 1}
-
-    class DerivedTask(BasePhaseTask):
-        # Does not override phase, should inherit "inherited"
-        def execute(self, ctx=None, **inputs):
-            return {"value": 2}
-
-    class OverriddenDerivedTask(BasePhaseTask):
-        # Overrides phase
-        phase = "overridden"
-
-        def execute(self, ctx=None, **inputs):
-            return {"value": 3}
-
-    register_task(BasePhaseTask)
-    register_task(DerivedTask)
-    register_task(OverriddenDerivedTask)
-
-    # Test inheritance
-    derived = DerivedTask(label="derived")
-    assert derived.phase == "inherited"
-
-    # Test override
-    overridden = OverriddenDerivedTask(label="overridden")
-    assert overridden.phase == "overridden"
-
-    # Verify workflow serialization
-    workflow = Workflow.from_tasks(tasks=[derived, overridden], links=[])
-    assert workflow.task_configs[0].phase == "inherited"
-    assert workflow.task_configs[1].phase == "overridden"
-
-
-# ============================================================================
-# MapTask tests (tasks.md 2.x)
-# ============================================================================
-
-
-class SimpleConfig(BaseModel):
-    prefix: str = "job"
-
-
-class SimpleTask(Task[SimpleConfig, dict]):
-    config_type = SimpleConfig
-    inputs = {}
-    outputs = {}
-
-    def execute(self, ctx=None, **inputs):
-        return {"result": f"{self.config.prefix}_{inputs['value']}"}
-
-
-register_task(SimpleTask)
-
-
-def test_map_task_execute(tmp_path):
-    """MapTask.execute() runs base_task for each item."""
-    base = SimpleTask(prefix="x")
-    map_task = MapTask(base, map_over="items")
-
-    run = _make_run(tmp_path)
-    with run.start() as ctx:
-        result = map_task.execute(ctx=ctx, items=[{"value": 1}, {"value": 2}])
-
-    assert result["results"][0]["result"] == "x_1"
-    assert result["results"][1]["result"] == "x_2"
-
-
-# ============================================================================
-# RunContext.from_run_dir tests (tasks.md 3.x)
-# ============================================================================
-
-
-def test_from_run_dir_reconstructs_hierarchy(tmp_path):
-    """from_run_dir should reconstruct the full hierarchy from disk."""
-    workspace, project, experiment = _make_hierarchy(tmp_path)
-    run = experiment.create_run(parameters={"lr": 0.001})
-
-    # Execute to create run.json with context
-    with run.start() as ctx:
-        ctx.set_result("test_key", {"data": 42})
-
-    # Now reconstruct from run_dir
-    run_dir = (
-        workspace.root / "projects" / project.id
-        / "experiments" / experiment.id / "runs" / run.id
-    )
-    restored = RunContext.from_run_dir(run_dir)
-
-    assert restored.run.id == run.id
-    assert restored.run.experiment.id == experiment.id
-    assert restored.run.experiment.project.id == project.id
-    assert restored.run.experiment.project.workspace.root == workspace.root
-    assert restored.work_dir == run_dir
-
-
-def test_from_run_dir_restores_context(tmp_path):
-    """from_run_dir should restore context.results from run.json."""
-    workspace, project, experiment = _make_hierarchy(tmp_path)
-    run = experiment.create_run(parameters={"batch_size": 32})
-
-    with run.start() as ctx:
-        ctx.set_result("my_result", {"value": 99})
-
-    run_dir = (
-        workspace.root / "projects" / project.id
-        / "experiments" / experiment.id / "runs" / run.id
-    )
-    restored = RunContext.from_run_dir(run_dir)
-
-    assert restored.context.results.get("my_result") == {"value": 99}
-    assert restored.run.parameters == {"batch_size": 32}
-
-
-def test_from_run_dir_supports_context_manager(tmp_path):
-    """from_run_dir result should work as context manager."""
-    workspace, project, experiment = _make_hierarchy(tmp_path)
-    run = experiment.create_run(parameters={})
-
-    with run.start() as ctx:
-        pass
-
-    run_dir = (
-        workspace.root / "projects" / project.id
-        / "experiments" / experiment.id / "runs" / run.id
-    )
-    restored = RunContext.from_run_dir(run_dir)
-
-    with restored as ctx:
-        ctx.set_result("new_key", "new_value")
-
-    # Verify run.json was updated
-    run_json = run_dir / "run.json"
-    data = json.loads(run_json.read_text())
-    assert "new_key" in data["context"]["results"]
-
-
-def test_from_run_dir_missing_run_json(tmp_path):
-    """from_run_dir should raise FileNotFoundError if run.json is missing."""
-    with pytest.raises(FileNotFoundError, match="run.json"):
-        RunContext.from_run_dir(tmp_path)
-
-
-# ============================================================================
-# RunContext.get_asset / find_asset tests (tasks.md 4.x)
-# ============================================================================
-
-
-def test_get_asset_by_scope(tmp_path):
-    """get_asset delegates to the correct scope's AssetLibrary."""
-    workspace, project, experiment = _make_hierarchy(tmp_path)
-
-    # Create a file to use as asset source
-    asset_src = tmp_path / "data.txt"
-    asset_src.write_text("test data")
-
-    # Register asset at project level
-    project.assets.import_asset("my_dataset", asset_src)
-
-    run = experiment.create_run(parameters={})
-    with run.start() as ctx:
-        asset = ctx.get_asset("my_dataset", scope="project")
-        assert asset is not None
-        assert asset.name == "my_dataset"
-
-        # Asset not at experiment level
-        assert ctx.get_asset("my_dataset", scope="experiment") is None
-
-
-def test_find_asset_fallback(tmp_path):
-    """find_asset searches experiment → project → workspace."""
-    workspace, project, experiment = _make_hierarchy(tmp_path)
-
-    asset_src = tmp_path / "global.txt"
-    asset_src.write_text("global")
-
-    # Register at workspace level only
-    workspace.assets.import_asset("shared_model", asset_src)
-
-    run = experiment.create_run(parameters={})
-    with run.start() as ctx:
-        # find_asset should find it at workspace level
-        asset = ctx.find_asset("shared_model")
-        assert asset is not None
-        assert asset.name == "shared_model"
-
-        # Non-existent asset
-        assert ctx.find_asset("nonexistent") is None
-
-
-def test_get_asset_invalid_scope(tmp_path):
-    """get_asset should raise ValueError for unknown scope."""
-    run = _make_run(tmp_path)
-    with run.start() as ctx:
-        with pytest.raises(ValueError, match="Unknown scope"):
-            ctx.get_asset("anything", scope="galaxy")
diff --git a/tests/test_resources.py b/tests/test_resources.py
deleted file mode 100644
index d2f56b8e..00000000
--- a/tests/test_resources.py
+++ /dev/null
@@ -1,112 +0,0 @@
-"""Tests for resource abstraction."""
-
-from __future__ import annotations
-
-import tempfile
-from pathlib import Path
-
-import pytest
-
-from molexp.workspace.resource import FileResource, FolderResource, AssetResource
-
-
-def test_file_resource_basic():
-    """Test basic FileResource operations."""
-    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
-        f.write("test content")
-        temp_path = Path(f.name)
-    
-    try:
-        # Create resource
-        resource = FileResource(f"file://{temp_path}")
-        
-        # Test properties
-        assert resource.uri == f"file://{temp_path}"
-        assert resource.path == temp_path
-        assert resource.exists()
-        
-        # Test read
-        content = resource.read()
-        assert content == b"test content"
-        
-        # Test write
-        resource.write(b"new content")
-        assert resource.read() == b"new content"
-    finally:
-        temp_path.unlink()
-
-
-def test_folder_resource_basic():
-    """Test basic FolderResource operations."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        tmppath = Path(tmpdir)
-        
-        # Create some files
-        (tmppath / "file1.txt").write_text("content1")
-        (tmppath / "file2.txt").write_text("content2")
-        (tmppath / "subdir").mkdir()
-        (tmppath / "subdir" / "file3.txt").write_text("content3")
-        
-        # Create resource
-        resource = FolderResource(f"file://{tmppath}")
-        
-        # Test properties
-        assert resource.uri == f"file://{tmppath}"
-        assert resource.path == tmppath
-        assert resource.exists()
-        
-        # Test list_files
-        files = resource.list_files()
-        assert len(files) == 3
-        assert all(f.is_file() for f in files)
-        
-        # Test read/write raise errors
-        with pytest.raises(NotImplementedError):
-            resource.read()
-        with pytest.raises(NotImplementedError):
-            resource.write(b"data")
-
-
-def test_asset_resource_basic():
-    """Test basic AssetResource operations."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        workspace_root = Path(tmpdir)
-        asset_id = "test123"
-        
-        # Create asset directory structure
-        asset_path = workspace_root / "assets" / asset_id / "data"
-        asset_path.parent.mkdir(parents=True)
-        asset_path.write_text("asset content")
-        
-        # Create resource
-        resource = AssetResource(f"asset://{asset_id}", workspace_root)
-        
-        # Test properties
-        assert resource.uri == f"asset://{asset_id}"
-        assert resource.asset_id == asset_id
-        assert resource.path == asset_path
-        assert resource.exists()
-        
-        # Test read
-        content = resource.read()
-        assert content == b"asset content"
-        
-        # Test write
-        resource.write(b"new asset content")
-        assert resource.read() == b"new asset content"
-
-
-def test_file_resource_nonexistent():
-    """Test FileResource with nonexistent file."""
-    resource = FileResource("file:///nonexistent/file.txt")
-    assert not resource.exists()
-    
-    with pytest.raises(FileNotFoundError):
-        resource.read()
-
-
-def test_folder_resource_nonexistent():
-    """Test FolderResource with nonexistent directory."""
-    resource = FolderResource("file:///nonexistent/dir")
-    assert not resource.exists()
-    assert resource.list_files() == []
diff --git a/tests/test_resume_policy.py b/tests/test_resume_policy.py
deleted file mode 100644
index 633f9f5a..00000000
--- a/tests/test_resume_policy.py
+++ /dev/null
@@ -1,141 +0,0 @@
-"""Tests for resume policy functionality."""
-
-import pytest
-
-from molexp.workspace.resume_policy import (
-    AlwaysResumePolicy,
-    NeverResumePolicy,
-    StatusBasedPolicy,
-    get_resume_policy,
-    RESUME_POLICIES,
-)
-from molexp.workspace.checkpoint import CheckpointState
-from datetime import datetime
-
-
-class MockRun:
-    """Mock Run object for testing."""
-    def __init__(self, status="pending"):
-        self.status = status
-
-
-def test_always_resume_policy():
-    """Test AlwaysResumePolicy always returns True."""
-    policy = AlwaysResumePolicy()
-    run = MockRun()
-    checkpoint = CheckpointState(
-        ckpt_id="test",
-        run_id="run_123",
-        experiment_id="exp_456",
-        project_id="proj_789",
-        timestamp=datetime.now(),
-        context={}
-    )
-    
-    assert policy.should_resume(run, checkpoint) is True
-
-
-def test_never_resume_policy():
-    """Test NeverResumePolicy always returns False."""
-    policy = NeverResumePolicy()
-    run = MockRun()
-    checkpoint = CheckpointState(
-        ckpt_id="test",
-        run_id="run_123",
-        experiment_id="exp_456",
-        project_id="proj_789",
-        timestamp=datetime.now(),
-        context={}
-    )
-    
-    assert policy.should_resume(run, checkpoint) is False
-
-
-def test_status_based_policy_failed():
-    """Test StatusBasedPolicy resumes for failed runs."""
-    from molexp.workspace.run import RunStatus
-    
-    policy = StatusBasedPolicy()
-    run = MockRun(status=RunStatus.FAILED)
-    checkpoint = CheckpointState(
-        ckpt_id="test",
-        run_id="run_123",
-        experiment_id="exp_456",
-        project_id="proj_789",
-        timestamp=datetime.now(),
-        context={}
-    )
-    
-    assert policy.should_resume(run, checkpoint) is True
-
-
-def test_status_based_policy_cancelled():
-    """Test StatusBasedPolicy resumes for cancelled runs."""
-    from molexp.workspace.run import RunStatus
-    
-    policy = StatusBasedPolicy()
-    run = MockRun(status=RunStatus.CANCELLED)
-    checkpoint = CheckpointState(
-        ckpt_id="test",
-        run_id="run_123",
-        experiment_id="exp_456",
-        project_id="proj_789",
-        timestamp=datetime.now(),
-        context={}
-    )
-    
-    assert policy.should_resume(run, checkpoint) is True
-
-
-def test_status_based_policy_succeeded():
-    """Test StatusBasedPolicy does not resume for succeeded runs."""
-    from molexp.workspace.run import RunStatus
-    
-    policy = StatusBasedPolicy()
-    run = MockRun(status=RunStatus.SUCCEEDED)
-    checkpoint = CheckpointState(
-        ckpt_id="test",
-        run_id="run_123",
-        experiment_id="exp_456",
-        project_id="proj_789",
-        timestamp=datetime.now(),
-        context={}
-    )
-    
-    assert policy.should_resume(run, checkpoint) is False
-
-
-def test_get_resume_policy_by_string():
-    """Test getting policy by string name."""
-    policy = get_resume_policy("always")
-    assert isinstance(policy, AlwaysResumePolicy)
-    
-    policy = get_resume_policy("never")
-    assert isinstance(policy, NeverResumePolicy)
-    
-    policy = get_resume_policy("status")
-    assert isinstance(policy, StatusBasedPolicy)
-
-
-def test_get_resume_policy_by_instance():
-    """Test getting policy by instance."""
-    custom_policy = AlwaysResumePolicy()
-    policy = get_resume_policy(custom_policy)
-    assert policy is custom_policy
-
-
-def test_get_resume_policy_invalid_string():
-    """Test getting policy with invalid string raises error."""
-    with pytest.raises(ValueError, match="Unknown resume policy"):
-        get_resume_policy("invalid_policy")
-
-
-def test_policy_registry():
-    """Test policy registry contains expected policies."""
-    assert "always" in RESUME_POLICIES
-    assert "never" in RESUME_POLICIES
-    assert "status" in RESUME_POLICIES
-    
-    assert isinstance(RESUME_POLICIES["always"], AlwaysResumePolicy)
-    assert isinstance(RESUME_POLICIES["never"], NeverResumePolicy)
-    assert isinstance(RESUME_POLICIES["status"], StatusBasedPolicy)
diff --git a/tests/test_server/__init__.py b/tests/test_server/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_server/conftest.py b/tests/test_server/conftest.py
new file mode 100644
index 00000000..6f8facb0
--- /dev/null
+++ b/tests/test_server/conftest.py
@@ -0,0 +1,39 @@
+"""Shared fixtures for server tests."""
+
+import pytest
+from fastapi.testclient import TestClient
+
+from molexp.server.app import create_app
+from molexp.server.dependencies import get_workspace
+from molexp.workspace import Workspace
+
+
+@pytest.fixture
+def workspace(tmp_path):
+    return Workspace(root=tmp_path, name="Test")
+
+
+@pytest.fixture
+def project(workspace):
+    return workspace.project("test-project")
+
+
+@pytest.fixture
+def experiment(project):
+    return project.experiment(
+        "test-exp",
+        workflow_source="train.py",
+        params={"lr": 1e-4},
+    )
+
+
+@pytest.fixture
+def run(experiment):
+    return experiment.run(parameters={"lr": 1e-4})
+
+
+@pytest.fixture
+def client(workspace):
+    app = create_app()
+    app.dependency_overrides[get_workspace] = lambda: workspace
+    return TestClient(app)
diff --git a/tests/test_server/test_experiment_routes.py b/tests/test_server/test_experiment_routes.py
new file mode 100644
index 00000000..25594575
--- /dev/null
+++ b/tests/test_server/test_experiment_routes.py
@@ -0,0 +1,40 @@
+"""Tests for experiment API routes."""
+
+
+
+class TestExperimentRoutes:
+    def test_list_empty(self, client, project):
+        resp = client.get(f"/api/projects/{project.id}/experiments")
+        assert resp.status_code == 200
+        assert resp.json() == []
+
+    def test_create_with_workflow(self, client, project):
+        resp = client.post(
+            f"/api/projects/{project.id}/experiments",
+            json={
+                "name": "baseline",
+                "workflow_source": "train.py",
+                "parameter_space": {"lr": [1e-4]},
+            },
+        )
+        assert resp.status_code == 201
+        data = resp.json()
+        assert data["name"] == "baseline"
+        assert data["workflow"] == "train.py"
+        assert data["parameterSpace"] == {"lr": [1e-4]}
+
+    def test_get(self, client, project, experiment):
+        resp = client.get(
+            f"/api/projects/{project.id}/experiments/{experiment.id}"
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["id"] == experiment.id
+        assert data["projectId"] == project.id
+        assert data["workflow"] == "train.py"
+
+    def test_delete(self, client, project, experiment):
+        resp = client.delete(
+            f"/api/projects/{project.id}/experiments/{experiment.id}"
+        )
+        assert resp.status_code == 200
diff --git a/tests/test_server/test_health.py b/tests/test_server/test_health.py
new file mode 100644
index 00000000..ca388983
--- /dev/null
+++ b/tests/test_server/test_health.py
@@ -0,0 +1,12 @@
+"""Tests for health endpoint."""
+
+
+class TestHealthEndpoint:
+    def test_health(self, client):
+        resp = client.get("/api/health")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["status"] == "healthy"
+        assert data["workspace_available"] is True
+        assert "capabilities" in data
+        assert "agent" in data["capabilities"]
diff --git a/tests/test_server/test_project_routes.py b/tests/test_server/test_project_routes.py
new file mode 100644
index 00000000..f5905556
--- /dev/null
+++ b/tests/test_server/test_project_routes.py
@@ -0,0 +1,38 @@
+"""Tests for project API routes."""
+
+
+
+class TestProjectRoutes:
+    def test_list_empty(self, client):
+        resp = client.get("/api/projects")
+        assert resp.status_code == 200
+        assert resp.json() == []
+
+    def test_create(self, client):
+        resp = client.post("/api/projects", json={"name": "QM9"})
+        assert resp.status_code == 201
+        data = resp.json()
+        assert data["name"] == "QM9"
+        assert data["id"] == "qm9"
+        assert "created" in data
+
+    def test_get(self, client, project):
+        resp = client.get(f"/api/projects/{project.id}")
+        assert resp.status_code == 200
+        assert resp.json()["id"] == project.id
+
+    def test_get_not_found(self, client):
+        resp = client.get("/api/projects/nonexistent")
+        assert resp.status_code == 404
+
+    def test_delete(self, client, project):
+        resp = client.delete(f"/api/projects/{project.id}")
+        assert resp.status_code == 200
+        resp2 = client.get(f"/api/projects/{project.id}")
+        assert resp2.status_code == 404
+
+    def test_list_after_create(self, client):
+        client.post("/api/projects", json={"name": "A"})
+        client.post("/api/projects", json={"name": "B"})
+        resp = client.get("/api/projects")
+        assert len(resp.json()) == 2
diff --git a/tests/test_server/test_registry_routes.py b/tests/test_server/test_registry_routes.py
new file mode 100644
index 00000000..ba3ee42f
--- /dev/null
+++ b/tests/test_server/test_registry_routes.py
@@ -0,0 +1,50 @@
+"""Tests for plugin registry routes."""
+
+
+class TestRegistryRoutes:
+    def test_plugins_lists_core(self, client):
+        resp = client.get("/api/plugins")
+
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["total"] >= 1
+        assert any(plugin["id"] == "core" for plugin in data["plugins"])
+
+    def test_plugins_lists_molq_manifest_when_supported(self, client, monkeypatch):
+        monkeypatch.setattr(
+            "molexp.server.routes.registry.discover_ui_plugins",
+            lambda: [
+                type(
+                    "Descriptor",
+                    (),
+                    {
+                        "id": "core",
+                        "title": "Core Workspace UI",
+                        "description": "Built-in Molexp workspace renderers and previews.",
+                        "ui_module": "core",
+                        "capabilities": ("workspace",),
+                        "metadata": {},
+                    },
+                )(),
+                type(
+                    "Descriptor",
+                    (),
+                    {
+                        "id": "molq",
+                        "title": "Molq",
+                        "description": "Scheduler-aware run viewers.",
+                        "ui_module": "molq",
+                        "capabilities": ("submit", "monitor"),
+                        "metadata": {"schedulers": ["slurm"]},
+                    },
+                )(),
+            ],
+        )
+
+        resp = client.get("/api/plugins")
+
+        assert resp.status_code == 200
+        data = resp.json()
+        molq = next(plugin for plugin in data["plugins"] if plugin["id"] == "molq")
+        assert molq["uiModule"] == "molq"
+        assert molq["metadata"] == {"schedulers": ["slurm"]}
diff --git a/tests/test_server/test_run_routes.py b/tests/test_server/test_run_routes.py
new file mode 100644
index 00000000..3943ee25
--- /dev/null
+++ b/tests/test_server/test_run_routes.py
@@ -0,0 +1,51 @@
+"""Tests for run API routes."""
+
+
+
+class TestRunRoutes:
+    def _prefix(self, project, experiment):
+        return f"/api/projects/{project.id}/experiments/{experiment.id}/runs"
+
+    def test_create(self, client, project, experiment):
+        resp = client.post(
+            self._prefix(project, experiment),
+            json={"parameters": {"lr": 1e-4}},
+        )
+        assert resp.status_code == 201
+        data = resp.json()
+        assert data["parameters"] == {"lr": 1e-4}
+        assert data["status"] == "pending"
+        assert data["projectId"] == project.id
+        assert data["experimentId"] == experiment.id
+
+    def test_create_captures_workflow_snapshot(self, client, project, experiment):
+        resp = client.post(
+            self._prefix(project, experiment),
+            json={"parameters": {}},
+        )
+        data = resp.json()
+        assert data["workflow"] is not None
+        assert data["workflow"]["source"] == "train.py"
+
+    def test_list(self, client, project, experiment):
+        client.post(self._prefix(project, experiment), json={"parameters": {}})
+        client.post(self._prefix(project, experiment), json={"parameters": {}})
+        resp = client.get(self._prefix(project, experiment))
+        assert len(resp.json()) == 2
+
+    def test_get(self, client, project, experiment, run):
+        run._update_metadata(executor_info={"backend": "molq", "scheduler": "slurm"})
+        resp = client.get(f"{self._prefix(project, experiment)}/{run.id}")
+        assert resp.status_code == 200
+        assert resp.json()["id"] == run.id
+        assert resp.json()["executorInfo"] == {"backend": "molq", "scheduler": "slurm"}
+
+    def test_update_status(self, client, project, experiment, run):
+        resp = client.patch(
+            f"{self._prefix(project, experiment)}/{run.id}/status",
+            json={"status": "succeeded"},
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["status"] == "succeeded"
+        assert data["finished"] is not None
diff --git a/tests/test_server/test_static_serving.py b/tests/test_server/test_static_serving.py
new file mode 100644
index 00000000..a42f06a2
--- /dev/null
+++ b/tests/test_server/test_static_serving.py
@@ -0,0 +1,119 @@
+"""Smoke tests for bundled frontend static asset serving."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from molexp.server.app import _find_bundled_webapp, create_app
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture()
+def mock_webapp(tmp_path: Path) -> Path:
+    """Minimal directory that mimics the rsbuild build output."""
+    root = tmp_path / "webapp"
+    root.mkdir()
+    (root / "index.html").write_text(
+        "<!DOCTYPE html><html><body>MolExp UI</body></html>"
+    )
+    (root / "favicon.ico").write_bytes(b"\x00")  # dummy favicon
+
+    static = root / "static" / "js"
+    static.mkdir(parents=True)
+    (static / "main.abc123.js").write_text("console.log('molexp');")
+
+    css = root / "static" / "css"
+    css.mkdir(parents=True)
+    (css / "main.abc123.css").write_text("body{margin:0}")
+
+    return root
+
+
+# ---------------------------------------------------------------------------
+# API-only mode (dev / no bundle)
+# ---------------------------------------------------------------------------
+
+
+class TestApiOnlyMode:
+    def test_root_returns_service_info(self) -> None:
+        app = create_app(serve_static=False)
+        with TestClient(app) as client:
+            resp = client.get("/")
+            assert resp.status_code == 200
+            data = resp.json()
+            assert data["service"] == "molexp"
+
+    def test_health_endpoint(self) -> None:
+        app = create_app(serve_static=False)
+        with TestClient(app) as client:
+            resp = client.get("/api/health")
+            assert resp.status_code == 200
+            assert resp.json()["status"] == "healthy"
+
+
+# ---------------------------------------------------------------------------
+# Production mode with bundled (mock) webapp
+# ---------------------------------------------------------------------------
+
+
+class TestStaticServing:
+    def test_index_served_at_root(self, mock_webapp: Path) -> None:
+        app = create_app(static_dir=mock_webapp)
+        with TestClient(app) as client:
+            resp = client.get("/")
+            assert resp.status_code == 200
+            assert "MolExp UI" in resp.text
+
+    def test_spa_fallback_for_client_routes(self, mock_webapp: Path) -> None:
+        app = create_app(static_dir=mock_webapp)
+        with TestClient(app) as client:
+            resp = client.get("/projects/abc/experiments/123")
+            assert resp.status_code == 200
+            assert "MolExp UI" in resp.text
+
+    def test_static_js_served(self, mock_webapp: Path) -> None:
+        app = create_app(static_dir=mock_webapp)
+        with TestClient(app) as client:
+            resp = client.get("/static/js/main.abc123.js")
+            assert resp.status_code == 200
+            assert "molexp" in resp.text
+
+    def test_static_css_served(self, mock_webapp: Path) -> None:
+        app = create_app(static_dir=mock_webapp)
+        with TestClient(app) as client:
+            resp = client.get("/static/css/main.abc123.css")
+            assert resp.status_code == 200
+
+    def test_root_file_served_directly(self, mock_webapp: Path) -> None:
+        """Files that exist at the webapp root (favicon etc.) are served as-is."""
+        app = create_app(static_dir=mock_webapp)
+        with TestClient(app) as client:
+            resp = client.get("/favicon.ico")
+            assert resp.status_code == 200
+
+    def test_api_takes_priority(self, mock_webapp: Path) -> None:
+        """API routes are not shadowed by the SPA fallback."""
+        app = create_app(static_dir=mock_webapp)
+        with TestClient(app) as client:
+            resp = client.get("/api/health")
+            assert resp.status_code == 200
+            assert resp.json()["status"] == "healthy"
+
+
+# ---------------------------------------------------------------------------
+# Bundle detection
+# ---------------------------------------------------------------------------
+
+
+class TestBundleDetection:
+    def test_returns_none_when_no_webapp(self) -> None:
+        result = _find_bundled_webapp()
+        # In a dev checkout without a built wheel this is None.
+        # In CI after a wheel build it might be a real path.
+        assert result is None or (result.is_dir() and (result / "index.html").exists())
diff --git a/tests/test_server_lifecycle.py b/tests/test_server_lifecycle.py
deleted file mode 100644
index 0e3c0818..00000000
--- a/tests/test_server_lifecycle.py
+++ /dev/null
@@ -1,121 +0,0 @@
-"""Tests for ServerManager lifecycle management with kill_on_exit."""
-
-import os
-import signal
-import time
-from pathlib import Path
-
-import pytest
-
-from molexp.server import ServerManager
-
-
-@pytest.fixture
-def manager(tmp_path):
-    """Create a ServerManager with temporary config directory."""
-    return ServerManager(config_dir=tmp_path / ".molexp_test")
-
-
-@pytest.fixture
-def cleanup_servers(manager):
-    """Ensure servers are stopped after test."""
-    yield
-    try:
-        manager.stop(ui=True)
-    except Exception:
-        pass
-
-
-def test_kill_on_exit_false_default(manager, cleanup_servers):
-    """Test that kill_on_exit defaults to False."""
-    # This test just verifies the parameter exists and defaults correctly
-    # Full integration testing would require subprocess spawning
-    
-    # Check that the manager can be initialized
-    assert manager is not None
-    assert hasattr(manager, '_background_pids')
-    assert isinstance(manager._background_pids, list)
-
-
-def test_background_pid_tracking(manager):
-    """Test that background PIDs are tracked when kill_on_exit=True."""
-    # Mock scenario - in real usage, pids would be populated by start()
-    manager._background_pids.append(12345)
-    manager._background_pids.append(67890)
-    
-    assert len(manager._background_pids) == 2
-    assert 12345 in manager._background_pids
-    assert 67890 in manager._background_pids
-
-
-def test_cleanup_handler_registration(manager):
-    """Test that cleanup handler can be registered."""
-    # This verifies the method exists and can be called
-    try:
-        manager._register_cleanup_handler()
-        # If we get here, the method exists and runs without error
-        assert True
-    except Exception as e:
-        pytest.fail(f"Failed to register cleanup handler: {e}")
-
-
-def test_cleanup_background_processes(manager):
-    """Test cleanup of background processes."""
-    # Add some fake PIDs that don't exist
-    manager._background_pids = [999999, 999998]
-    
-    # This should not raise an error even for non-existent PIDs
-    manager._cleanup_background_processes()
-    
-    # PIDs should be cleared
-    assert len(manager._background_pids) == 0
-
-
-def test_start_api_server_signature(manager):
-    """Test that _start_api_server accepts kill_on_exit parameter."""
-    import inspect
-    
-    sig = inspect.signature(manager._start_api_server)
-    params = sig.parameters
-    
-    assert 'kill_on_exit' in params
-    assert params['kill_on_exit'].default is False
-
-
-def test_start_ui_server_signature(manager):
-    """Test that _start_ui_server accepts kill_on_exit parameter."""
-    import inspect
-    
-    sig = inspect.signature(manager._start_ui_server)
-    params = sig.parameters
-    
-    assert 'kill_on_exit' in params
-    assert params['kill_on_exit'].default is False
-
-
-def test_start_method_signature(manager):
-    """Test that start method accepts kill_on_exit parameter."""
-    import inspect
-    
-    sig = inspect.signature(manager.start)
-    params = sig.parameters
-    
-    assert 'kill_on_exit' in params
-    assert params['kill_on_exit'].default is False
-
-
-@pytest.mark.integration
-def test_server_lifecycle_integration(manager, cleanup_servers, tmp_path):
-    """Integration test for server lifecycle (requires actual server start)."""
-    # This test is marked as integration and may be skipped in unit test runs
-    pytest.skip("Integration test - requires full server environment")
-    
-    # Example integration test structure:
-    # 1. Start server with kill_on_exit=True
-    # 2. Verify server is running
-    # 3. Simulate parent process exit
-    # 4. Verify server was killed
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])
diff --git a/tests/test_sweep/__init__.py b/tests/test_sweep/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_sweep/test_graph.py b/tests/test_sweep/test_graph.py
new file mode 100644
index 00000000..0e9ef11f
--- /dev/null
+++ b/tests/test_sweep/test_graph.py
@@ -0,0 +1,141 @@
+"""Tests for :mod:`molexp.sweep` — sweep-level parallelism.
+
+Phase 1 scope (see ``docs/spec/unified-pydantic-graph-dispatch.md`` §6):
+the sweep graph fans out over ``(mol_run, experiment)`` replicas and
+bounds concurrency with a ``jobs`` semaphore.  Backend selection is
+*not* part of Phase 1 — every replica executes in-process via
+``experiment.workflow.execute(...)``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+import pytest
+
+from molexp.sweep import SweepReplica, run_sweep
+
+
+class _FakeWorkflow:
+    """Minimal stand-in for :class:`WorkflowSpec`; records calls and sleeps."""
+
+    def __init__(self, *, delay: float = 0.0, fail: bool = False, tag: str = "") -> None:
+        self.delay = delay
+        self.fail = fail
+        self.tag = tag
+        self.calls: list[tuple[Any, Any]] = []
+
+    async def execute(self, run: Any = None, profile_config: Any = None, **_: Any) -> str:
+        self.calls.append((run, profile_config))
+        if self.delay:
+            await asyncio.sleep(self.delay)
+        if self.fail:
+            raise RuntimeError(f"boom-{self.tag}")
+        return f"done-{self.tag}"
+
+
+@dataclass
+class _FakeExperiment:
+    id: str
+    workflow: _FakeWorkflow
+
+
+@dataclass
+class _FakeRun:
+    id: str
+
+
+def _make_replica(rid: str, *, delay: float = 0.0, fail: bool = False) -> SweepReplica:
+    return SweepReplica(
+        mol_run=_FakeRun(id=rid),
+        experiment=_FakeExperiment(id=rid, workflow=_FakeWorkflow(delay=delay, fail=fail, tag=rid)),
+    )
+
+
+@pytest.mark.asyncio
+class TestRunSweep:
+    async def test_empty_replicas_returns_empty_state(self) -> None:
+        state = await run_sweep([], jobs=1)
+        assert state.outputs == {}
+        assert state.failures == {}
+
+    async def test_single_replica_executes(self) -> None:
+        rep = _make_replica("r1")
+        state = await run_sweep([rep], jobs=1)
+        assert state.outputs == {"r1": "done-r1"}
+        assert state.failures == {}
+
+    async def test_jobs_1_is_sequential(self) -> None:
+        """Three 0.1s replicas with ``jobs=1`` take ~0.3s (serialized)."""
+        delay = 0.1
+        reps = [_make_replica(f"r{i}", delay=delay) for i in range(3)]
+        t0 = time.perf_counter()
+        state = await run_sweep(reps, jobs=1)
+        wall = time.perf_counter() - t0
+        assert len(state.outputs) == 3
+        # 10% slack for scheduler jitter
+        assert wall >= 3 * delay * 0.9, f"expected sequential ~{3*delay}s, got {wall:.3f}s"
+
+    async def test_jobs_N_is_parallel(self) -> None:
+        """Three 0.2s replicas with ``jobs=3`` take ~0.2s (all concurrent)."""
+        delay = 0.2
+        reps = [_make_replica(f"r{i}", delay=delay) for i in range(3)]
+        t0 = time.perf_counter()
+        state = await run_sweep(reps, jobs=3)
+        wall = time.perf_counter() - t0
+        assert len(state.outputs) == 3
+        assert wall < 2 * delay, f"expected parallel ~{delay}s, got {wall:.3f}s"
+
+    async def test_semaphore_bounds_concurrency(self) -> None:
+        """Four 0.2s replicas with ``jobs=2`` take ~0.4s (two waves)."""
+        delay = 0.2
+        reps = [_make_replica(f"r{i}", delay=delay) for i in range(4)]
+        t0 = time.perf_counter()
+        state = await run_sweep(reps, jobs=2)
+        wall = time.perf_counter() - t0
+        assert len(state.outputs) == 4
+        assert wall >= 2 * delay * 0.9, f"expected two waves ~{2*delay}s, got {wall:.3f}s"
+        assert wall < 3 * delay, f"expected < {3*delay}s, got {wall:.3f}s"
+
+    async def test_failure_isolated_does_not_block_others(self) -> None:
+        """One failing replica is recorded in ``failures`` without blocking others."""
+        reps = [
+            _make_replica("good1"),
+            _make_replica("bad", fail=True),
+            _make_replica("good2"),
+        ]
+        state = await run_sweep(reps, jobs=3)
+        assert set(state.outputs.keys()) == {"good1", "good2"}
+        assert set(state.failures.keys()) == {"bad"}
+        assert "boom-bad" in state.failures["bad"]
+
+    async def test_profile_config_is_forwarded(self) -> None:
+        """``profile_config`` reaches each replica's ``workflow.execute``."""
+        from molexp.config import ProfileConfig
+
+        cfg = ProfileConfig({"epochs": 7}, name="smoke")
+        reps = [_make_replica(f"r{i}") for i in range(2)]
+        await run_sweep(reps, profile_config=cfg, jobs=2)
+        for rep in reps:
+            calls = rep.experiment.workflow.calls
+            assert len(calls) == 1
+            _, passed_cfg = calls[0]
+            assert passed_cfg is cfg
+
+    async def test_jobs_defaults_to_1(self) -> None:
+        """Without explicit jobs, concurrency is 1 (sequential)."""
+        delay = 0.05
+        reps = [_make_replica(f"r{i}", delay=delay) for i in range(3)]
+        t0 = time.perf_counter()
+        await run_sweep(reps)
+        wall = time.perf_counter() - t0
+        assert wall >= 3 * delay * 0.9
+
+    async def test_jobs_clamped_to_minimum_1(self) -> None:
+        """Non-positive ``jobs`` is clamped up to 1 (don't deadlock on Semaphore(0))."""
+        reps = [_make_replica("r1")]
+        state = await run_sweep(reps, jobs=0)
+        assert state.outputs == {"r1": "done-r1"}
diff --git a/tests/test_task_submission.py b/tests/test_task_submission.py
deleted file mode 100644
index 7654e211..00000000
--- a/tests/test_task_submission.py
+++ /dev/null
@@ -1,389 +0,0 @@
-"""Tests for Task submission protocol."""
-
-from __future__ import annotations
-
-from collections.abc import Generator
-from pathlib import Path
-from typing import Any
-from unittest.mock import Mock, MagicMock
-
-import pytest
-from pydantic import BaseModel
-
-from molexp.workflow.task import Task
-from molexp.workflow.engine import WorkflowEngine
-from molexp.workflow.workflow import Workflow
-from molexp.workspace import Workspace
-
-
-# ============================================================================
-# Test Helpers
-# ============================================================================
-
-
-def _make_hierarchy(tmp_path):
-    workspace = Workspace(root=tmp_path / "workspace", name="Test")
-    workspace.materialize()
-    project = workspace.create_project(name="Project")
-    experiment = project.create_experiment(name="Experiment")
-    return workspace, project, experiment
-
-
-def _make_run(tmp_path, parameters=None):
-    _, _, experiment = _make_hierarchy(tmp_path)
-    return experiment.create_run(parameters=parameters or {})
-
-
-# ============================================================================
-# Test Tasks
-# ============================================================================
-
-
-class SimpleConfig(BaseModel):
-    value: int = 42
-
-
-class LocalTask(Task[SimpleConfig, dict]):
-    """Task without submittable - executes locally."""
-
-    config_type = SimpleConfig
-    inputs = {}
-    outputs = {"result": int}
-    submittable = None  # Explicit None for local execution
-
-    def execute(self, ctx=None, **inputs):
-        return {"result": self.config.value * 2}
-
-
-class SubmittableTask(Task[SimpleConfig, dict]):
-    """Task with submittable - submits via molq."""
-
-    config_type = SimpleConfig
-    inputs = {}
-    outputs = {"result": int, "job_id": str}
-    submittable = "molq"
-
-    def execute(self, ctx=None, **inputs):
-        # Fallback for local execution
-        return {"result": self.config.value * 2, "job_id": "local"}
-
-    def submit(self, ctx=None, **inputs) -> Generator[dict, int, dict]:
-        """Submit job via generator protocol."""
-        # Create JobSpec (using dict for simplicity in tests)
-        job_spec = {
-            "execution": {"command": f"echo {self.config.value}"},
-            "resources": {"cpu_count": 1},
-        }
-
-        # Yield JobSpec, receive job_id
-        job_id = yield job_spec
-
-        # Return results with job_id
-        return {
-            "result": self.config.value * 2,
-            "job_id": job_id,
-        }
-
-
-class MissingSubmitTask(Task[SimpleConfig, dict]):
-    """Task with submittable but no submit() implementation."""
-
-    config_type = SimpleConfig
-    inputs = {}
-    outputs = {"result": int}
-    submittable = "molq"
-
-    def execute(self, ctx=None, **inputs):
-        return {"result": 0}
-
-    # Does not implement submit()
-
-
-# ============================================================================
-# Tests
-# ============================================================================
-
-
-def test_task_submittable_class_attribute():
-    """Test that submittable can be set as class attribute."""
-    assert LocalTask.submittable is None
-    assert SubmittableTask.submittable == "molq"
-
-    # Instance should inherit class attribute
-    local = LocalTask()
-    assert local.submittable is None
-
-    submittable = SubmittableTask()
-    assert submittable.submittable == "molq"
-
-
-def test_task_submittable_instance_override():
-    """Test that instance can override class-level submittable."""
-    task = LocalTask()
-    assert task.submittable is None
-
-    # Override at instance level
-    task.submittable = "custom"
-    assert task.submittable == "custom"
-    assert LocalTask.submittable is None  # Class unchanged
-
-
-def test_submit_not_implemented_error():
-    """Test that submit() raises NotImplementedError with clear message."""
-    task = MissingSubmitTask()
-
-    with pytest.raises(NotImplementedError, match="submittable='molq'"):
-        # Trigger generator
-        gen = task.submit()
-        next(gen)
-
-
-def test_local_task_execution(tmp_path):
-    """Test that task with submittable=None executes locally."""
-    task = LocalTask(value=10)
-    workflow = Workflow.from_tasks(tasks=[task], links=[])
-
-    engine = WorkflowEngine(workflow)
-    run = _make_run(tmp_path)
-
-    with run.start() as ctx:
-        results = engine.execute(ctx)
-
-    assert task.task_id in results
-    assert results[task.task_id]["result"] == 20
-
-
-def test_submittable_task_without_submitor_fails(tmp_path):
-    """Test that submittable task without registered submitor raises error."""
-    task = SubmittableTask(value=10)
-    workflow = Workflow.from_tasks(tasks=[task], links=[])
-
-    engine = WorkflowEngine(workflow)
-    run = _make_run(tmp_path)
-
-    # Error is caught by workflow engine and stored, not raised
-    with run.start() as ctx:
-        results = engine.execute(ctx)
-
-    # Task should have failed
-    assert task.task_id not in results
-    assert task.task_id in ctx.context.errors
-    error = ctx.context.errors[task.task_id]
-    assert "Submitor backend 'molq' not configured" in error["message"]
-
-
-def test_submitor_registration():
-    """Test that submitors can be registered."""
-    workflow = Workflow.from_tasks(tasks=[], links=[])
-    engine = WorkflowEngine(workflow)
-
-    # Create mock submitor
-    mock_submitor = Mock()
-    mock_submitor.submit = Mock(return_value=123)
-    mock_submitor.query = Mock(return_value={})
-    mock_submitor.cancel = Mock()
-
-    engine.register_submitor("molq", mock_submitor)
-    assert "molq" in engine._submitors
-    assert engine._submitors["molq"] == mock_submitor
-
-
-def test_generator_protocol_handling(tmp_path):
-    """Test that engine handles generator protocol correctly."""
-    task = SubmittableTask(value=10)
-    workflow = Workflow.from_tasks(tasks=[task], links=[])
-
-    engine = WorkflowEngine(workflow)
-
-    # Mock submitor that returns a job_id
-    mock_submitor = Mock()
-    mock_submitor.submit = Mock(return_value=123)
-    mock_submitor.query = Mock(return_value={})
-
-    engine._submitors["molq"] = mock_submitor
-
-    run = _make_run(tmp_path)
-
-    with run.start() as ctx:
-        results = engine.execute(ctx)
-
-    # Verify submission happened
-    assert mock_submitor.submit.called
-    job_spec = mock_submitor.submit.call_args[0][0]
-    assert "execution" in job_spec
-    assert "command" in job_spec["execution"]
-
-    # Verify results
-    assert task.task_id in results
-    assert results[task.task_id]["result"] == 20
-    assert results[task.task_id]["job_id"] == 123
-
-
-def test_submission_tracking_in_context(tmp_path):
-    """Test that submissions are tracked in RunContext."""
-    task = SubmittableTask(value=10)
-    workflow = Workflow.from_tasks(tasks=[task], links=[])
-
-    engine = WorkflowEngine(workflow)
-
-    # Mock submitor
-    mock_submitor = Mock()
-    mock_submitor.submit = Mock(return_value=456)
-    mock_submitor.query = Mock(return_value={})
-
-    engine._submitors["molq"] = mock_submitor
-
-    run = _make_run(tmp_path)
-
-    with run.start() as ctx:
-        engine.execute(ctx)
-
-        # Check submissions were tracked in context.execution
-        assert "submissions" in ctx.context.execution
-        assert task.task_id in ctx.context.execution["submissions"]
-        submissions = ctx.context.execution["submissions"][task.task_id]
-        assert len(submissions) == 1
-        assert submissions[0]["job_id"] == 456
-        assert submissions[0]["backend"] == "molq"
-
-
-def test_mixed_local_and_submittable_tasks(tmp_path):
-    """Test workflow with both local and submittable tasks."""
-    local_task = LocalTask(value=5)
-    submit_task = SubmittableTask(value=10)
-
-    workflow = Workflow.from_tasks(tasks=[local_task, submit_task], links=[])
-
-    engine = WorkflowEngine(workflow)
-
-    # Mock submitor
-    mock_submitor = Mock()
-    mock_submitor.submit = Mock(return_value=789)
-    mock_submitor.query = Mock(return_value={})
-    engine._submitors["molq"] = mock_submitor
-
-    run = _make_run(tmp_path)
-
-    with run.start() as ctx:
-        results = engine.execute(ctx)
-
-    # Both tasks executed
-    assert local_task.task_id in results
-    assert submit_task.task_id in results
-
-    # Local task executed directly
-    assert results[local_task.task_id]["result"] == 10
-
-    # Submittable task went through submitor
-    assert mock_submitor.submit.called
-    assert results[submit_task.task_id]["result"] == 20
-    assert results[submit_task.task_id]["job_id"] == 789
-
-
-def test_job_monitoring_with_blocking(tmp_path):
-    """Test that blocking jobs are monitored until completion."""
-    from molq.resources import JobSpec, ExecutionSpec, ResourceSpec
-    from molq.jobstatus import JobStatus
-
-    # Create task that submits with blocking enabled
-    class BlockingTask(Task[SimpleConfig, dict]):
-        config_type = SimpleConfig
-        inputs = {}
-        outputs = {"result": int, "job_id": int}
-        submittable = "molq"
-
-        def execute(self, ctx=None, **inputs):
-            return {"result": 0, "job_id": 0}
-
-        def submit(self, ctx=None, **inputs) -> Generator[dict, int, dict]:
-            job_spec = JobSpec(
-                execution=ExecutionSpec(
-                    cmd="echo test",
-                    block=True  # Enable blocking
-                ),
-                resources=ResourceSpec(cpu_count=1),
-            )
-            job_id = yield job_spec
-            return {"result": self.config.value * 2, "job_id": job_id}
-
-    task = BlockingTask(value=10)
-    workflow = Workflow.from_tasks(tasks=[task], links=[])
-    engine = WorkflowEngine(workflow)
-
-    # Mock submitor with status progression
-    mock_submitor = Mock()
-    mock_submitor.submit = Mock(return_value=999)
-
-    # Simulate job lifecycle: PENDING -> RUNNING -> COMPLETED
-    status_sequence = [
-        {999: JobStatus(job_id=999, status=JobStatus.Status.PENDING, name="test_job")},
-        {999: JobStatus(job_id=999, status=JobStatus.Status.RUNNING, name="test_job")},
-        {999: JobStatus(job_id=999, status=JobStatus.Status.COMPLETED, name="test_job")},
-    ]
-    mock_submitor.query = Mock(side_effect=status_sequence)
-
-    engine._submitors["molq"] = mock_submitor
-
-    run = _make_run(tmp_path)
-
-    with run.start() as ctx:
-        results = engine.execute(ctx)
-
-    # Verify job was submitted
-    assert mock_submitor.submit.called
-
-    # Verify query was called multiple times (monitoring)
-    assert mock_submitor.query.call_count == 3
-
-    # Verify task completed successfully
-    assert task.task_id in results
-    assert results[task.task_id]["job_id"] == 999
-
-
-def test_job_monitoring_failure(tmp_path):
-    """Test that failed jobs raise errors."""
-    from molq.resources import JobSpec, ExecutionSpec, ResourceSpec
-    from molq.jobstatus import JobStatus
-
-    # Create task that submits with blocking enabled
-    class FailingTask(Task[SimpleConfig, dict]):
-        config_type = SimpleConfig
-        inputs = {}
-        outputs = {"result": int}
-        submittable = "molq"
-
-        def execute(self, ctx=None, **inputs):
-            return {"result": 0}
-
-        def submit(self, ctx=None, **inputs) -> Generator[dict, int, dict]:
-            job_spec = JobSpec(
-                execution=ExecutionSpec(cmd="exit 1", block=True),
-                resources=ResourceSpec(cpu_count=1),
-            )
-            job_id = yield job_spec
-            return {"result": self.config.value * 2}
-
-    task = FailingTask(value=10)
-    workflow = Workflow.from_tasks(tasks=[task], links=[])
-    engine = WorkflowEngine(workflow)
-
-    # Mock submitor with failure
-    mock_submitor = Mock()
-    mock_submitor.submit = Mock(return_value=888)
-    mock_submitor.query = Mock(return_value={
-        888: JobStatus(job_id=888, status=JobStatus.Status.FAILED, name="failing_job")
-    })
-
-    engine._submitors["molq"] = mock_submitor
-
-    run = _make_run(tmp_path)
-
-    # Task should fail
-    with run.start() as ctx:
-        results = engine.execute(ctx)
-
-    # Task should have failed
-    assert task.task_id not in results
-    assert task.task_id in ctx.context.errors
-    error = ctx.context.errors[task.task_id]
-    assert "Job 888 failed" in error["message"]
diff --git a/tests/test_workflow/__init__.py b/tests/test_workflow/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_workflow/test_context.py b/tests/test_workflow/test_context.py
new file mode 100644
index 00000000..b3899815
--- /dev/null
+++ b/tests/test_workflow/test_context.py
@@ -0,0 +1,51 @@
+"""Tests for TaskContext — workflow/workspace bridge."""
+
+from molexp.config import ProfileConfig
+from molexp.workflow.context import ActorContext, TaskContext
+
+
+class TestTaskContext:
+    def test_workflow_properties(self):
+        ctx = TaskContext(state={"x": 1}, deps="my_deps", inputs=42)
+        assert ctx.state == {"x": 1}
+        assert ctx.deps == "my_deps"
+        assert ctx.inputs == 42
+
+    def test_workspace_methods_return_none_without_run(self):
+        ctx = TaskContext(state=None, deps=None, inputs=None)
+        assert ctx.save_artifact("test", {}) is None
+        assert ctx.get_artifact_path("test") is None
+        assert ctx.find_asset("missing") is None
+        assert ctx.checkpoint() is None
+        assert ctx.get_result("key") is None
+
+    def test_set_result_noop_without_run(self):
+        ctx = TaskContext(state=None, deps=None, inputs=None)
+        ctx.set_result("key", "value")  # should not raise
+
+
+class TestTaskContextRunContext:
+    def test_run_context_none_without_run(self):
+        ctx = TaskContext(state=None, deps=None, inputs=None)
+        assert ctx.run_context is None
+        # ctx.config always returns a ProfileConfig, defaults-only when unset
+        assert ctx.config.name is None
+        assert len(ctx.config) == 0
+
+    def test_run_context_returns_attached(self):
+        sentinel = object()
+        ctx = TaskContext(state=None, deps=None, inputs=None, run_context=sentinel)
+        assert ctx.run_context is sentinel
+
+    def test_profile_config_exposes_user_data(self):
+        cfg = ProfileConfig({"epochs": 5, "dataset": "md17"}, name="smoke")
+        ctx = TaskContext(state=None, deps=None, inputs=None, config=cfg)
+        assert ctx.config.name == "smoke"
+        assert ctx.config["epochs"] == 5
+        assert ctx.config["dataset"] == "md17"
+
+
+class TestActorContext:
+    def test_inherits_task_context(self):
+        ctx = ActorContext(state={"x": 1}, deps=None, inputs=None)
+        assert ctx.state == {"x": 1}
diff --git a/tests/test_workflow/test_protocols.py b/tests/test_workflow/test_protocols.py
new file mode 100644
index 00000000..e415bcba
--- /dev/null
+++ b/tests/test_workflow/test_protocols.py
@@ -0,0 +1,56 @@
+"""Tests for workflow protocols — Runnable / Streamable."""
+
+from molexp.workflow import Actor, ActorContext, Runnable, Streamable, Task, TaskContext
+
+
+class TestRunnableProtocol:
+    def test_task_subclass_satisfies(self):
+        class MyTask(Task):
+            async def execute(self, ctx: TaskContext) -> int:
+                return 1
+
+        assert isinstance(MyTask(), Runnable)
+
+    def test_external_class_satisfies(self):
+        class External:
+            async def execute(self, ctx) -> dict:
+                return {}
+
+        assert isinstance(External(), Runnable)
+
+    def test_plain_object_does_not_satisfy(self):
+        class NotATask:
+            pass
+
+        assert not isinstance(NotATask(), Runnable)
+
+    def test_sync_execute_does_not_satisfy(self):
+        class SyncOnly:
+            def execute(self, ctx):
+                return 1
+
+        # sync method still satisfies the structural check at runtime
+        # (Protocol only checks method existence, not async-ness)
+        assert isinstance(SyncOnly(), Runnable)
+
+    def test_callable_without_execute_does_not_satisfy(self):
+        async def bare_fn(ctx):
+            return 1
+
+        assert not isinstance(bare_fn, Runnable)
+
+
+class TestStreamableProtocol:
+    def test_actor_subclass_satisfies(self):
+        class MyActor(Actor):
+            async def run(self, ctx: ActorContext):
+                yield 1
+
+        assert isinstance(MyActor(), Streamable)
+
+    def test_external_streamer_satisfies(self):
+        class External:
+            async def run(self, ctx):
+                yield 1
+
+        assert isinstance(External(), Streamable)
diff --git a/tests/test_workflow/test_runtime.py b/tests/test_workflow/test_runtime.py
new file mode 100644
index 00000000..2f9219a4
--- /dev/null
+++ b/tests/test_workflow/test_runtime.py
@@ -0,0 +1,246 @@
+"""Tests for workflow execution through pydantic-graph runtime."""
+
+import json
+
+import pytest
+
+from molexp.workflow import Task, TaskContext, WorkflowBuilder, workflow
+from molexp.workspace import Workspace
+
+
+@pytest.mark.asyncio
+class TestFunctionalExecution:
+    async def test_single_task(self):
+        wf = workflow(name="single")
+
+        @wf.task
+        async def double(ctx: TaskContext) -> int:
+            return (ctx.inputs or 5) * 2
+
+        result = await wf.build().execute()
+        assert result.status == "completed"
+        assert result.outputs["double"] == 10
+
+    async def test_chain(self):
+        wf = workflow(name="chain")
+
+        @wf.task
+        async def step_a(ctx: TaskContext) -> int:
+            return 10
+
+        @wf.task(depends_on=["step_a"])
+        async def step_b(ctx: TaskContext) -> int:
+            return ctx.inputs + 5
+
+        result = await wf.build().execute()
+        assert result.outputs == {"step_a": 10, "step_b": 15}
+
+    async def test_failure_propagates(self):
+        wf = workflow(name="fail")
+
+        @wf.task
+        async def boom(ctx):
+            raise RuntimeError("oops")
+
+        result = await wf.build().execute()
+        assert result.status == "failed"
+
+    async def test_run_context_is_forwarded_to_tasks(self, tmp_path):
+        from molexp.config import ProfileConfig
+
+        wf = workflow(name="with-run-context")
+
+        class RunContextStub:
+            """Minimal stub — profile fixed at construction, no late-bind."""
+
+            def __init__(self, *, config: ProfileConfig | None = None):
+                self.run = None
+                self.work_dir = tmp_path / "run"
+                self.config = config or ProfileConfig({}, name=None)
+                self.context = type("ContextStub", (), {"status": {}})()
+
+            def _save_context(self) -> None:
+                return None
+
+        run_ctx = RunContextStub(config=ProfileConfig({"epochs": 1}, name="smoke"))
+
+        @wf.task
+        async def inspect(ctx: TaskContext) -> bool:
+            assert ctx.run_context is run_ctx
+            assert ctx.config.name == "smoke"
+            assert ctx.config["epochs"] == 1
+            return True
+
+        result = await wf.build().execute(run_context=run_ctx)
+        assert result.status == "completed"
+        assert result.outputs["inspect"] is True
+
+    async def test_run_context_with_profile_config_raises(self, tmp_path):
+        """Passing run_context and profile_config is a hard error — no late-bind."""
+        from molexp.config import ProfileConfig
+
+        wf = workflow(name="no-late-bind")
+
+        class RunContextStub:
+            def __init__(self):
+                self.run = None
+                self.work_dir = tmp_path / "run"
+                self.config = ProfileConfig({}, name=None)
+                self.context = type("ContextStub", (), {"status": {}})()
+
+        @wf.task
+        async def noop(ctx: TaskContext) -> None:
+            return None
+
+        with pytest.raises(ValueError, match="Cannot combine run_context"):
+            await wf.build().execute(
+                run_context=RunContextStub(),
+                profile_config=ProfileConfig({"x": 1}, name="smoke"),
+            )
+
+    async def test_run_is_managed_by_runtime(self, tmp_path):
+        from molexp.config import ProfileConfig
+
+        workspace = Workspace(root=tmp_path / "lab", name="Test Lab")
+        project = workspace.project("demo")
+        experiment = project.experiment("runtime")
+        run = experiment.run(parameters={"seed": 42})
+
+        wf = workflow(name="managed-run")
+
+        @wf.task
+        async def inspect(ctx: TaskContext) -> str:
+            assert ctx.run_context is not None
+            assert ctx.run_context.run is run
+            assert ctx.run_context.config.name == "smoke"
+            assert ctx.config["epochs"] == 1
+            ctx.set_result("epochs", ctx.config["epochs"])
+            return "ok"
+
+        profile_cfg = ProfileConfig({"epochs": 1}, name="smoke")
+        result = await wf.build().execute(run=run, profile_config=profile_cfg)
+
+        assert result.status == "completed"
+        assert result.outputs["inspect"] == "ok"
+        # Profile is orthogonal to status — run succeeded.
+        assert run.status == "succeeded"
+        assert run.metadata.profile == "smoke"
+        assert run.metadata.config["epochs"] == 1
+
+        run_json = json.loads((run.run_dir / "run.json").read_text())
+        assert run_json["context"]["results"]["epochs"] == 1
+
+    async def test_default_profile_is_empty_config(self, tmp_path):
+        workspace = Workspace(root=tmp_path / "lab", name="Test Lab")
+        project = workspace.project("demo")
+        experiment = project.experiment("runtime")
+        run = experiment.run(parameters={"seed": 42})
+
+        wf = workflow(name="no-profile")
+
+        @wf.task
+        async def inspect(ctx: TaskContext) -> str:
+            assert ctx.config.name is None
+            assert len(ctx.config) == 0
+            return "ok"
+
+        result = await wf.build().execute(run=run)
+        assert result.status == "completed"
+        assert run.metadata.profile is None
+
+    async def test_run_and_run_context_are_mutually_exclusive(self, tmp_path):
+        workspace = Workspace(root=tmp_path / "lab", name="Test Lab")
+        project = workspace.project("demo")
+        experiment = project.experiment("runtime")
+        run = experiment.run(parameters={})
+
+        wf = workflow(name="exclusive")
+
+        @wf.task
+        async def noop(ctx: TaskContext) -> None:
+            return None
+
+        with run.start() as ctx:
+            with pytest.raises(ValueError, match="either run or run_context"):
+                await wf.build().execute(run=run, run_context=ctx)
+
+
+@pytest.mark.asyncio
+class TestOOPExecution:
+    async def test_task_subclass(self):
+        class AddTen(Task):
+            async def execute(self, ctx: TaskContext) -> int:
+                return (ctx.inputs or 0) + 10
+
+        spec = WorkflowBuilder(name="oop").add(AddTen()).build()
+        result = await spec.execute()
+        assert result.outputs["add_ten"] == 10
+
+
+@pytest.mark.asyncio
+class TestProtocolExecution:
+    async def test_external_runnable(self):
+        class External:
+            async def execute(self, ctx) -> int:
+                return 99
+
+        spec = WorkflowBuilder(name="ext").add(External(), name="ext").build()
+        result = await spec.execute()
+        assert result.outputs["ext"] == 99
+
+    async def test_mixed_task_types(self):
+        class OOP(Task):
+            async def execute(self, ctx: TaskContext) -> int:
+                return 10
+
+        class External:
+            async def execute(self, ctx) -> int:
+                return ctx.inputs + 90
+
+        spec = (
+            WorkflowBuilder(name="mixed")
+            .add(OOP(), name="oop")
+            .add(External(), name="ext", depends_on=["oop"])
+            .build()
+        )
+        result = await spec.execute()
+        assert result.outputs == {"oop": 10, "ext": 100}
+
+
+@pytest.mark.asyncio
+class TestParallelExecution:
+    async def test_independent_tasks_parallel(self):
+        wf = workflow(name="parallel")
+
+        @wf.task
+        async def a(ctx):
+            return "a"
+
+        @wf.task
+        async def b(ctx):
+            return "b"
+
+        result = await wf.build().execute()
+        assert result.outputs == {"a": "a", "b": "b"}
+
+    async def test_diamond_dependency(self):
+        wf = workflow(name="diamond")
+
+        @wf.task
+        async def root(ctx):
+            return 1
+
+        @wf.task(depends_on=["root"])
+        async def left(ctx):
+            return ctx.inputs + 10
+
+        @wf.task(depends_on=["root"])
+        async def right(ctx):
+            return ctx.inputs + 20
+
+        @wf.task(depends_on=["left", "right"])
+        async def merge(ctx):
+            return ctx.inputs["left"] + ctx.inputs["right"]
+
+        result = await wf.build().execute()
+        assert result.outputs["merge"] == 32
diff --git a/tests/test_workflow/test_spec.py b/tests/test_workflow/test_spec.py
new file mode 100644
index 00000000..acb154db
--- /dev/null
+++ b/tests/test_workflow/test_spec.py
@@ -0,0 +1,116 @@
+"""Tests for WorkflowSpec / WorkflowBuilder / DSL."""
+
+
+from molexp.workflow import (
+    Task,
+    TaskContext,
+    WorkflowBuilder,
+    workflow,
+)
+from molexp.workflow.spec import TaskRegistration, _stable_workflow_id
+
+
+class TestWorkflowDSL:
+    def test_single_task(self):
+        wf = workflow(name="simple")
+
+        @wf.task
+        async def fetch(ctx):
+            return 1
+
+        spec = wf.build()
+        assert spec.name == "simple"
+        assert len(spec._tasks) == 1
+        assert spec._tasks[0].name == "fetch"
+
+    def test_dependencies(self):
+        wf = workflow(name="chain")
+
+        @wf.task
+        async def a(ctx):
+            return 1
+
+        @wf.task(depends_on=["a"])
+        async def b(ctx):
+            return 2
+
+        spec = wf.build()
+        assert spec._tasks[1].depends_on == ["a"]
+
+    def test_custom_name(self):
+        wf = workflow(name="named")
+
+        @wf.task(name="custom_name")
+        async def fn(ctx):
+            return 1
+
+        spec = wf.build()
+        assert spec._tasks[0].name == "custom_name"
+
+    def test_actor_decorator(self):
+        wf = workflow(name="stream")
+
+        @wf.actor
+        async def streamer(ctx):
+            yield 1
+
+        spec = wf.build()
+        assert spec._tasks[0].is_actor is True
+
+
+class TestWorkflowBuilder:
+    def test_add_task(self):
+        class DoubleTask(Task):
+            async def execute(self, ctx: TaskContext) -> int:
+                return 2
+
+        spec = WorkflowBuilder(name="oop").add(DoubleTask()).build()
+        assert len(spec._tasks) == 1
+        assert spec._tasks[0].name == "double"
+
+    def test_add_external_runnable(self):
+        class External:
+            async def execute(self, ctx) -> int:
+                return 42
+
+        spec = WorkflowBuilder(name="ext").add(External(), name="ext").build()
+        assert spec._tasks[0].name == "ext"
+
+    def test_chaining(self):
+        class A(Task):
+            async def execute(self, ctx):
+                return 1
+
+        class B(Task):
+            async def execute(self, ctx):
+                return 2
+
+        spec = (
+            WorkflowBuilder(name="chain")
+            .add(A())
+            .add(B(), depends_on=["a"])
+            .build()
+        )
+        assert len(spec._tasks) == 2
+
+    def test_strip_task_suffix(self):
+        class FetchTask(Task):
+            async def execute(self, ctx):
+                return 1
+
+        spec = WorkflowBuilder(name="strip").add(FetchTask()).build()
+        assert spec._tasks[0].name == "fetch"
+
+
+class TestStableWorkflowId:
+    def test_deterministic(self):
+        regs = [TaskRegistration("a", lambda: None, []), TaskRegistration("b", lambda: None, ["a"])]
+        id1 = _stable_workflow_id("test", regs)
+        id2 = _stable_workflow_id("test", regs)
+        assert id1 == id2
+
+    def test_different_name_different_id(self):
+        regs = [TaskRegistration("a", lambda: None, [])]
+        id1 = _stable_workflow_id("wf1", regs)
+        id2 = _stable_workflow_id("wf2", regs)
+        assert id1 != id2
diff --git a/tests/test_workflow_nodes.py b/tests/test_workflow_nodes.py
deleted file mode 100644
index c2c74dce..00000000
--- a/tests/test_workflow_nodes.py
+++ /dev/null
@@ -1,182 +0,0 @@
-"""Test the new unified node system with static configuration."""
-
-import pytest
-from pydantic import BaseModel, Field
-
-from molexp.workflow.control import MapTask, ReduceTask
-from molexp.workflow.task import Task
-from molexp.workflow.plugin.registry import get_task_registry, register
-
-# Get the global registry instance
-task_registry = get_task_registry()
-
-
-# Example tasks for testing
-
-
-class DoubleConfig(BaseModel):
-    """Config for doubling a number."""
-
-    multiplier: int = 2
-
-
-class DoubleNode(Task[DoubleConfig, int]):
-    """Double a number."""
-
-    config_type = DoubleConfig
-    inputs = {"value": int}
-    outputs = {"result": int}
-
-    def execute(self, ctx=None, **inputs) -> dict[str, int]:
-        value = inputs.get("value", 0)
-        return {"result": value * self.config.multiplier}
-
-
-class SumConfig(BaseModel):
-    """Config for summing numbers."""
-
-    initial: float = 0.0
-
-
-class SumNode(Task[SumConfig, float]):
-    """Sum a list of numbers."""
-
-    config_type = SumConfig
-
-    def execute(self, *inputs: float) -> float:
-        return sum(inputs) + self.config.initial
-
-
-class ConstantConfig(BaseModel):
-    """Config for constant generator."""
-
-    value: int = Field(..., description="Constant value to return")
-
-
-@register("test.constant")
-class ConstantNode(Task[ConstantConfig, int]):
-    """Generate a constant value."""
-
-    config_type = ConstantConfig
-
-    def execute(self, ctx=None, **inputs) -> int:
-        return self.config.value
-
-
-def test_transform_node():
-    """Test basic node with static config."""
-    # Config is set at construction
-    node = DoubleNode(multiplier=3)
-
-    # Execute only receives input data
-    result = node(value=5)
-    assert result == {"result": 15}
-
-    # Test with default config
-    node_default = DoubleNode()
-    result = node_default(value=5)
-    assert result == {"result": 10}
-
-
-def test_generator_node():
-    """Test generator node (no inputs)."""
-    # Config at construction
-    node = ConstantNode(value=42)
-
-    # Execute with no arguments
-    result = node()
-    assert result == 42
-
-
-def test_node_registration():
-    """Test node registry."""
-    # Check that ConstantNode was registered
-    assert task_registry.has("test.constant")
-
-    # Get registration
-    reg = task_registry.get("test.constant")
-    assert reg.task_class == ConstantNode
-    assert reg.config_class == ConstantConfig
-
-
-def test_map_node():
-    """Test MapTask control flow."""
-    # Create a collection
-    numbers = [1, 2, 3, 4, 5]
-
-    # Create base task with static config
-    double_node = DoubleNode(multiplier=2)
-
-    # Create map task (no runtime data in __init__)
-    map_task = MapTask(double_node, map_over="items")
-
-    # Execute with collection via **inputs
-    result = map_task.execute(ctx=None, items=numbers)
-
-    assert result == {"results": [{"result": 2}, {"result": 4}, {"result": 6}, {"result": 8}, {"result": 10}]}
-
-
-def test_reduce_node():
-    """Test ReduceTask control flow."""
-    numbers = [1, 2, 3, 4, 5]
-
-    # Config at construction (method only)
-    reduce_task = ReduceTask(method="sum")
-
-    # Execute with data via **inputs
-    result = reduce_task.execute(ctx=None, collection=numbers)
-    assert result == {"result": 15}
-
-    # Test mean
-    reduce_task_mean = ReduceTask(method="mean")
-    result = reduce_task_mean.execute(ctx=None, collection=numbers)
-    assert result == {"result": 3.0}
-
-
-def test_config_validation():
-    """Test that config validation works at construction."""
-    # Valid config
-    node = DoubleNode(multiplier=3)
-    result = node(value=5)
-    assert result == {"result": 15}
-
-    # Invalid config should raise error at construction
-    with pytest.raises(ValueError):
-        node = DoubleNode(multiplier="not_a_number")
-
-
-def test_config_serialization():
-    """Test config serialization methods."""
-    node = DoubleNode(multiplier=5)
-
-    # Get config as dict using dump()
-    config_dict = node.dump()
-    assert config_dict == {"multiplier": 5}
-
-    # Create node from config dict
-    node2 = DoubleNode(**config_dict)
-    assert node2.config.multiplier == 5
-    result = node2(value=10)
-    assert result == {"result": 50}
-
-
-def test_node_repr():
-    """Test node representation."""
-    node = DoubleNode(multiplier=3)
-    repr_str = repr(node)
-    assert "DoubleNode" in repr_str
-    assert "multiplier=3" in repr_str
-
-
-if __name__ == "__main__":
-    # Run tests
-    test_transform_node()
-    test_generator_node()
-    test_node_registration()
-    test_map_node()
-    test_reduce_node()
-    test_config_validation()
-    test_config_serialization()
-    test_node_repr()
-
-    print("✓ All tests passed!")
diff --git a/tests/test_workflow_persistence.py b/tests/test_workflow_persistence.py
deleted file mode 100644
index d2604ffb..00000000
--- a/tests/test_workflow_persistence.py
+++ /dev/null
@@ -1,101 +0,0 @@
-"""Tests for workflow persistence, replay, and strict mappings."""
-
-from __future__ import annotations
-
-from pydantic import BaseModel
-import pytest
-
-from molexp.workflow.engine import WorkflowEngine
-from molexp.workflow.link import Link
-from molexp.workflow.registry import register_task
-from molexp.workflow.task import Task
-from molexp.workflow.workflow import Workflow
-from molexp.workspace import Workspace
-
-
-def _make_run(tmp_path):
-    workspace = Workspace(root=tmp_path / "workspace", name="Test")
-    workspace.materialize()
-    project = workspace.create_project(name="Project")
-    experiment = project.create_experiment(name="Experiment")
-    return experiment.create_run(parameters={})
-
-
-class AddConfig(BaseModel):
-    value: int = 1
-
-
-class AddTask(Task[AddConfig, dict]):
-    config_type = AddConfig
-    inputs = {"x": int}
-    outputs = {"result": int}
-
-    def execute(self, ctx=None, **inputs):
-        return {"result": inputs["x"] + self.config.value}
-
-
-class MultiplyConfig(BaseModel):
-    factor: int = 2
-
-
-class MultiplyTask(Task[MultiplyConfig, dict]):
-    config_type = MultiplyConfig
-    inputs = {"value": int}
-    outputs = {"result": int}
-
-    def execute(self, ctx=None, **inputs):
-        return {"result": inputs["value"] * self.config.factor}
-
-
-def test_workflow_roundtrip(tmp_path):
-    register_task(AddTask)
-    register_task(MultiplyTask)
-
-    add = AddTask(value=2)
-    mul = MultiplyTask(factor=3)
-
-    link = Link(
-        source=add.task_id,
-        target=mul.task_id,
-        mapping={"result": "value"},
-    )
-    workflow = Workflow.from_tasks([add, mul], links=[link])
-    path = tmp_path / "workflow.json"
-    workflow.save(path)
-
-    loaded = Workflow.load(path)
-    run = _make_run(tmp_path)
-
-    with run.context() as ctx:
-        engine = WorkflowEngine(loaded)
-        results = engine.execute(ctx, x=4)
-
-    assert results[add.task_id]["result"] == 6
-    assert results[mul.task_id]["result"] == 18
-
-
-def test_missing_mapping_rejected():
-    register_task(AddTask)
-    register_task(MultiplyTask)
-
-    add = AddTask(value=2)
-    mul = MultiplyTask(factor=3)
-
-    link = Link(source=add.task_id, target=mul.task_id, mapping={})
-    workflow = Workflow.from_tasks([add, mul], links=[link])
-
-    with pytest.raises(ValueError, match="must declare a mapping"):
-        WorkflowEngine(workflow)
-
-
-def test_missing_required_input_fails(tmp_path):
-    register_task(AddTask)
-
-    add = AddTask(value=2)
-    workflow = Workflow.from_tasks([add], links=[])
-    run = _make_run(tmp_path)
-
-    with run.context() as ctx:
-        engine = WorkflowEngine(workflow)
-        with pytest.raises(ValueError, match="missing required inputs"):
-            engine.execute(ctx)
diff --git a/tests/test_workspace.py b/tests/test_workspace.py
deleted file mode 100644
index f1c4fa20..00000000
--- a/tests/test_workspace.py
+++ /dev/null
@@ -1,240 +0,0 @@
-"""Tests for Workspace class with metadata/object separation."""
-
-from __future__ import annotations
-
-import tempfile
-from pathlib import Path
-
-import pytest
-
-from molexp.workspace import Workspace, Project, Experiment, Run
-
-
-def test_workspace_creation():
-    """Test workspace creation with materialize pattern."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        # Create workspace (no side effects)
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        
-        # Verify metadata auto-generated
-        assert workspace.id == "test-workspace"  # Slugified from name
-        assert workspace.name == "Test Workspace"
-        assert workspace.metadata.created_at is not None
-        assert workspace.root == Path(tmpdir).resolve()
-        
-        # Explicitly materialize
-        workspace.materialize()
-        
-        # Verify filesystem created
-        assert (workspace.root / "workspace.json").exists()
-        assert workspace.assets is not None
-
-
-def test_workspace_load():
-    """Test loading workspace from disk."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        # Create and materialize workspace
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        workspace.materialize()
-        
-        # Load workspace from disk
-        loaded = Workspace.load(tmpdir)
-        
-        # Verify metadata preserved
-        assert loaded.id == workspace.id
-        assert loaded.name == workspace.name
-        assert loaded.metadata.created_at == workspace.metadata.created_at
-
-
-def test_project_creation():
-    """Test creating a project with auto-generated metadata."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        workspace.materialize()
-        
-        # Create project (auto-materialized by workspace.create_project)
-        project = workspace.create_project(name="Test Project")
-        
-        # Verify auto-generated fields
-        assert project.id == "test-project"  # Slugified from name
-        assert project.name == "Test Project"
-        assert project.metadata.created_at is not None
-        assert project.metadata.updated_at is not None
-        
-        # Verify filesystem created
-        project_dir = workspace.root / "projects" / project.id
-        assert project_dir.exists()
-        assert (project_dir / "project.json").exists()
-        
-        # Verify project has asset library
-        assert project.assets is not None
-
-
-def test_project_get_and_list():
-    """Test retrieving and listing projects."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        workspace.materialize()
-        
-        # Create multiple projects
-        project1 = workspace.create_project(name="Project 1")
-        project2 = workspace.create_project(name="Project 2")
-        project3 = workspace.create_project(name="Project 3")
-        
-        # Get by ID
-        retrieved = workspace.get_project("project-1")
-        assert retrieved.id == project1.id
-        assert retrieved.name == project1.name
-        
-        # Get by name (slugified)
-        retrieved2 = workspace.get_project("Project 2")
-        assert retrieved2.id == project2.id
-        
-        # List projects
-        projects = workspace.list_projects()
-        assert len(projects) == 3
-        assert {p.name for p in projects} == {"Project 1", "Project 2", "Project 3"}
-
-
-def test_experiment_creation():
-    """Test creating an experiment with auto-generated UUID."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        workspace.materialize()
-        project = workspace.create_project(name="Test Project")
-        
-        # Create experiment (auto-materialized by project.create_experiment)
-        experiment = project.create_experiment(name="Test Experiment")
-        
-        # Verify auto-generated fields
-        assert experiment.id is not None  # UUID auto-generated
-        assert experiment.name == "Test Experiment"
-        assert experiment.metadata.created_at is not None
-        
-        # Verify parent references
-        assert experiment.project is project
-        assert experiment.workspace is workspace
-        
-        # Verify filesystem created
-        exp_dir = workspace.root / "projects" / project.id / "experiments" / experiment.id
-        assert exp_dir.exists()
-        assert (exp_dir / "experiment.json").exists()
-        
-        # Verify experiment has asset library
-        assert experiment.assets is not None
-
-
-def test_run_creation():
-    """Test creating a run with auto-generated UUID."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        workspace.materialize()
-        project = workspace.create_project(name="Test Project")
-        experiment = project.create_experiment(name="Test Experiment")
-        
-        # Create run (auto-materialized by experiment.create_run)
-        run = experiment.create_run(parameters={"lr": 0.001, "batch_size": 32})
-        
-        # Verify auto-generated fields
-        assert run.id is not None  # UUID auto-generated
-        assert run.metadata.created_at is not None
-        assert run.parameters == {"lr": 0.001, "batch_size": 32}
-        assert run.status == "pending"
-        
-        # Verify parent reference
-        assert run.experiment is experiment
-        
-        # Verify filesystem created
-        run_dir = (
-            workspace.root / "projects" / project.id / 
-            "experiments" / experiment.id / "runs" / run.id
-        )
-        assert run_dir.exists()
-        assert (run_dir / "run.json").exists()
-
-
-def test_hierarchical_asset_libraries():
-    """Test that asset libraries are isolated at each level."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        workspace.materialize()
-        project = workspace.create_project(name="Test Project")
-        experiment = project.create_experiment(name="Test Experiment")
-        run = experiment.create_run(parameters={})
-        
-        # Create test file
-        source_file = Path(tmpdir) / "test.txt"
-        source_file.write_text("test data")
-        
-        # Import asset at each level (using correct API)
-        ws_asset = workspace.assets.import_asset("ws_asset", source_file)
-        proj_asset = project.assets.import_asset("proj_asset", source_file)
-        exp_asset = experiment.assets.import_asset("exp_asset", source_file)
-        
-        # Verify isolation - each library only has its own asset
-        assert len(workspace.assets.list_assets()) == 1
-        assert workspace.assets.list_assets()[0].name == "ws_asset"
-        
-        assert len(project.assets.list_assets()) == 1
-        assert project.assets.list_assets()[0].name == "proj_asset"
-        
-        assert len(experiment.assets.list_assets()) == 1
-        assert experiment.assets.list_assets()[0].name == "exp_asset"
-
-
-def test_run_context_creation():
-    """Test creating runtime context from run."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        workspace.materialize()
-        project = workspace.create_project(name="Test Project")
-        experiment = project.create_experiment(name="Test Experiment")
-        run = experiment.create_run(parameters={"lr": 0.001})
-
-        # Create context via context manager
-        run_ctx = run.context()
-        assert run_ctx.run is run
-
-        # Verify context has correct IDs and work_dir
-        ctx = run_ctx.context
-        assert ctx.run_id == run.id
-        assert ctx.experiment_id == experiment.id
-        assert ctx.project_id == project.id
-        assert run_ctx.work_dir == (
-            workspace.root / "projects" / project.id /
-            "experiments" / experiment.id / "runs" / run.id
-        )
-
-
-def test_metadata_persistence():
-    """Test that metadata persists correctly across save/load."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        # Create workspace and project
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        workspace.materialize()
-        project = workspace.create_project(name="Test Project")
-        
-        # Reload workspace
-        workspace2 = Workspace.load(tmpdir)
-        project2 = workspace2.get_project(project.id)
-        
-        # Verify metadata matches
-        assert project2.id == project.id
-        assert project2.name == project.name
-        assert project2.metadata.created_at == project.metadata.created_at
-
-
-def test_no_side_effects_on_construction():
-    """Test that constructing entities has no filesystem side effects."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        # Create workspace without materializing
-        workspace = Workspace(root=tmpdir, name="Test Workspace")
-        
-        # Verify no files created yet
-        assert not (Path(tmpdir) / "workspace.json").exists()
-        
-        # Now materialize
-        workspace.materialize()
-        
-        # Verify files created
-        assert (Path(tmpdir) / "workspace.json").exists()
diff --git a/tests/test_workspace/__init__.py b/tests/test_workspace/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_workspace/conftest.py b/tests/test_workspace/conftest.py
new file mode 100644
index 00000000..04186469
--- /dev/null
+++ b/tests/test_workspace/conftest.py
@@ -0,0 +1,57 @@
+"""Shared fixtures for workspace tests."""
+
+from __future__ import annotations
+
+import pytest
+
+from molexp.workspace import Workspace
+from molexp.workspace.checkpoint import CheckpointState
+
+
+@pytest.fixture
+def workspace(tmp_path):
+    return Workspace(root=tmp_path, name="Test Lab")
+
+
+@pytest.fixture
+def project(workspace):
+    return workspace.project("test-project")
+
+
+@pytest.fixture
+def experiment(project):
+    return project.experiment(
+        "test-experiment",
+        workflow_source="train.py",
+        params={"lr": 1e-4},
+        git_commit="abc123",
+    )
+
+
+@pytest.fixture
+def run(experiment):
+    return experiment.run(parameters={"lr": 1e-4})
+
+
+@pytest.fixture
+def checkpoint_state():
+    from datetime import datetime
+
+    return CheckpointState(
+        ckpt_id="ckpt_test123",
+        run_id="run-1",
+        experiment_id="exp-1",
+        project_id="proj-1",
+        timestamp=datetime.now(),
+        context={"results": {"acc": 0.9}},
+    )
+
+
+class MockRun:
+    def __init__(self, status: str = "pending"):
+        self.status = status
+
+
+@pytest.fixture
+def mock_run():
+    return MockRun
diff --git a/tests/test_workspace/test_checkpoint.py b/tests/test_workspace/test_checkpoint.py
new file mode 100644
index 00000000..3714e8a6
--- /dev/null
+++ b/tests/test_workspace/test_checkpoint.py
@@ -0,0 +1,45 @@
+"""Tests for checkpoint system."""
+
+
+from molexp.workspace.checkpoint import Checkpoint, generate_checkpoint_id
+
+
+class TestCheckpointState:
+    def test_creation(self, checkpoint_state):
+        assert checkpoint_state.ckpt_id == "ckpt_test123"
+        assert checkpoint_state.run_id == "run-1"
+
+    def test_defaults(self, checkpoint_state):
+        assert checkpoint_state.version == "1.0"
+        assert checkpoint_state.metadata == {}
+
+
+class TestCheckpoint:
+    def test_generate_id(self):
+        cid = generate_checkpoint_id()
+        assert cid.startswith("ckpt_")
+        assert len(cid) > 5
+
+    def test_save_creates_file(self, tmp_path, checkpoint_state):
+        path = Checkpoint.save(tmp_path, checkpoint_state)
+        assert path.exists()
+
+    def test_save_creates_latest_symlink(self, tmp_path, checkpoint_state):
+        Checkpoint.save(tmp_path, checkpoint_state)
+        latest = tmp_path / "latest.json"
+        assert latest.exists() or latest.is_symlink()
+
+    def test_load_roundtrip(self, tmp_path, checkpoint_state):
+        path = Checkpoint.save(tmp_path, checkpoint_state)
+        loaded = Checkpoint.load(path)
+        assert loaded.ckpt_id == checkpoint_state.ckpt_id
+        assert loaded.context == checkpoint_state.context
+
+    def test_get_latest_none_when_empty(self, tmp_path):
+        assert Checkpoint.get_latest(tmp_path) is None
+
+    def test_get_latest_returns_most_recent(self, tmp_path, checkpoint_state):
+        Checkpoint.save(tmp_path, checkpoint_state)
+        latest = Checkpoint.get_latest(tmp_path)
+        assert latest is not None
+        assert latest.ckpt_id == checkpoint_state.ckpt_id
diff --git a/tests/test_workspace/test_models.py b/tests/test_workspace/test_models.py
new file mode 100644
index 00000000..e42a6a60
--- /dev/null
+++ b/tests/test_workspace/test_models.py
@@ -0,0 +1,101 @@
+"""Tests for workspace.models — frozen metadata."""
+
+from datetime import datetime
+
+import pytest
+
+from molexp.workspace.models import (
+    ErrorInfo,
+    ExperimentMetadata,
+    ProjectMetadata,
+    RunMetadata,
+    WorkflowSnapshotRef,
+    WorkspaceMetadata,
+)
+
+
+class TestWorkspaceMetadata:
+    def test_creation(self):
+        m = WorkspaceMetadata(id="lab", name="My Lab")
+        assert m.id == "lab"
+        assert m.name == "My Lab"
+        assert isinstance(m.created_at, datetime)
+
+    def test_frozen(self):
+        m = WorkspaceMetadata(id="lab", name="My Lab")
+        with pytest.raises(Exception):
+            m.name = "changed"
+
+    def test_no_projects_field(self):
+        m = WorkspaceMetadata(id="lab", name="My Lab")
+        assert not hasattr(m, "projects")
+
+    def test_no_updated_at_field(self):
+        m = WorkspaceMetadata(id="lab", name="My Lab")
+        assert not hasattr(m, "updated_at")
+
+
+class TestProjectMetadata:
+    def test_creation(self):
+        m = ProjectMetadata(id="qm9", name="QM9")
+        assert m.description == ""
+        assert m.tags == []
+
+    def test_frozen(self):
+        m = ProjectMetadata(id="qm9", name="QM9")
+        with pytest.raises(Exception):
+            m.description = "changed"
+
+    def test_no_experiments_field(self):
+        m = ProjectMetadata(id="qm9", name="QM9")
+        assert not hasattr(m, "experiments")
+
+    def test_no_assets_field(self):
+        m = ProjectMetadata(id="qm9", name="QM9")
+        assert not hasattr(m, "assets")
+
+    def test_model_copy_update(self):
+        m = ProjectMetadata(id="qm9", name="QM9")
+        m2 = m.model_copy(update={"description": "updated"})
+        assert m.description == ""
+        assert m2.description == "updated"
+
+
+class TestExperimentMetadata:
+    def test_workflow_fields(self):
+        m = ExperimentMetadata(
+            id="exp-1",
+            name="baseline",
+            workflow_source="train.py",
+            workflow_type="python",
+            parameter_space={"lr": [1e-4]},
+            git_commit="abc123",
+        )
+        assert m.workflow_source == "train.py"
+        assert m.workflow_type == "python"
+        assert m.parameter_space == {"lr": [1e-4]}
+        assert m.git_commit == "abc123"
+
+    def test_workflow_fields_optional(self):
+        m = ExperimentMetadata(id="exp-1", name="bare")
+        assert m.workflow_source is None
+        assert m.parameter_space == {}
+
+
+class TestRunMetadata:
+    def test_workflow_snapshot(self):
+        snap = WorkflowSnapshotRef(source="train.py", git_commit="abc")
+        m = RunMetadata(id="run-1", workflow_snapshot=snap)
+        assert m.workflow_snapshot.source == "train.py"
+        assert m.status == "pending"
+
+    def test_error_info(self):
+        err = ErrorInfo(type="ValueError", message="bad", timestamp=datetime.now())
+        m = RunMetadata(id="run-1", error=err)
+        assert m.error.type == "ValueError"
+
+    def test_frozen_status_update_via_copy(self):
+        m = RunMetadata(id="run-1")
+        m2 = m.model_copy(update={"status": "running"})
+        assert m.status == "pending"
+        assert m2.status == "running"
diff --git a/tests/test_workspace/test_resume_policy.py b/tests/test_workspace/test_resume_policy.py
new file mode 100644
index 00000000..98c7807f
--- /dev/null
+++ b/tests/test_workspace/test_resume_policy.py
@@ -0,0 +1,67 @@
+"""Tests for resume policies."""
+
+import pytest
+
+from molexp.workspace.resume_policy import (
+    RESUME_POLICIES,
+    AlwaysResumePolicy,
+    NeverResumePolicy,
+    StatusBasedPolicy,
+    get_resume_policy,
+)
+from molexp.workspace.run import RunStatus
+
+
+class TestAlwaysResumePolicy:
+    def test_always_returns_true(self, mock_run, checkpoint_state):
+        policy = AlwaysResumePolicy()
+        assert policy.should_resume(mock_run(), checkpoint_state) is True
+
+    def test_true_for_any_status(self, mock_run, checkpoint_state):
+        for s in RunStatus:
+            assert policy_result(AlwaysResumePolicy(), mock_run(s.value), checkpoint_state) is True
+
+
+class TestNeverResumePolicy:
+    def test_always_returns_false(self, mock_run, checkpoint_state):
+        policy = NeverResumePolicy()
+        assert policy.should_resume(mock_run(), checkpoint_state) is False
+
+
+class TestStatusBasedPolicy:
+    def test_resumes_for_failed(self, mock_run, checkpoint_state):
+        policy = StatusBasedPolicy()
+        assert policy.should_resume(mock_run("failed"), checkpoint_state) is True
+
+    def test_resumes_for_cancelled(self, mock_run, checkpoint_state):
+        policy = StatusBasedPolicy()
+        assert policy.should_resume(mock_run("cancelled"), checkpoint_state) is True
+
+    def test_does_not_resume_for_succeeded(self, mock_run, checkpoint_state):
+        policy = StatusBasedPolicy()
+        assert policy.should_resume(mock_run("succeeded"), checkpoint_state) is False
+
+    def test_does_not_resume_for_pending(self, mock_run, checkpoint_state):
+        policy = StatusBasedPolicy()
+        assert policy.should_resume(mock_run("pending"), checkpoint_state) is False
+
+
+class TestResumePolicyRegistry:
+    def test_get_by_string(self):
+        for name in ("always", "never", "status"):
+            assert get_resume_policy(name) is not None
+
+    def test_get_by_instance_returns_same(self):
+        policy = AlwaysResumePolicy()
+        assert get_resume_policy(policy) is policy
+
+    def test_invalid_string_raises(self):
+        with pytest.raises(ValueError):
+            get_resume_policy("nonexistent")
+
+    def test_registry_keys(self):
+        assert set(RESUME_POLICIES.keys()) == {"always", "never", "status"}
+
+
+def policy_result(policy, run, ckpt):
+    return policy.should_resume(run, ckpt)
diff --git a/tests/test_workspace/test_run_cancel.py b/tests/test_workspace/test_run_cancel.py
new file mode 100644
index 00000000..ae0048ad
--- /dev/null
+++ b/tests/test_workspace/test_run_cancel.py
@@ -0,0 +1,46 @@
+"""Tests for Run.cancel() public method."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from molexp.workspace.run import RunStatus
+
+
+class TestRunCancel:
+    def test_cancel_pending_run(self, run):
+        assert run.status == "pending"
+        run.cancel()
+        assert run.status == RunStatus.CANCELLED
+        assert run.status == "cancelled"
+
+    def test_cancel_writes_run_json(self, run):
+        run.cancel()
+        data = json.loads((run.run_dir / "run.json").read_text())
+        assert data["status"] == "cancelled"
+
+    def test_cancel_running_run(self, run):
+        run._set_status(RunStatus.RUNNING)
+        run.cancel()
+        assert run.status == RunStatus.CANCELLED
+
+    def test_cancel_is_idempotent(self, run):
+        run.cancel()
+        run.cancel()
+        assert run.status == RunStatus.CANCELLED
+
+    def test_cancel_does_not_modify_parameters(self, run):
+        original_params = dict(run.parameters)
+        run.cancel()
+        assert run.parameters == original_params
+
+    def test_cancel_does_not_modify_job_ids(self, run):
+        run._update_metadata(
+            executor_info={"job_id": "uuid-123", "scheduler_job_id": "456"}
+        )
+        run.cancel()
+        assert run.metadata.executor_info["job_id"] == "uuid-123"
+        assert run.metadata.executor_info["scheduler_job_id"] == "456"
+        assert run.status == "cancelled"
diff --git a/tests/test_workspace/test_run_context.py b/tests/test_workspace/test_run_context.py
new file mode 100644
index 00000000..49957127
--- /dev/null
+++ b/tests/test_workspace/test_run_context.py
@@ -0,0 +1,139 @@
+"""Tests for RunContext lifecycle."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from molexp.workspace.run import RunStatus
+
+
+class TestRunContextLifecycle:
+    def test_enter_sets_running(self, run):
+        with run.start():
+            assert run.status == "running"
+
+    def test_exit_success(self, run):
+        with run.start():
+            pass
+        assert run.status == RunStatus.SUCCEEDED
+
+    def test_exit_failure(self, experiment):
+        run = experiment.run()
+        try:
+            with run.start():
+                raise ValueError("boom")
+        except ValueError:
+            pass
+        assert run.status == RunStatus.FAILED
+        assert run.metadata.error is not None
+        assert run.metadata.error.type == "ValueError"
+        assert run.metadata.error.message == "boom"
+
+    def test_finished_at_set(self, run):
+        with run.start():
+            pass
+        assert run.metadata.finished_at is not None
+
+    def test_creates_directories(self, run):
+        with run.start() as ctx:
+            assert ctx.work_dir.exists()
+            assert ctx.artifacts_dir.exists()
+            assert ctx.logs_dir.exists()
+
+
+class TestRunContextResults:
+    def test_set_and_get_result(self, run):
+        with run.start() as ctx:
+            ctx.set_result("acc", 0.95)
+            assert ctx.get_result("acc") == 0.95
+
+    def test_missing_result_returns_none(self, run):
+        with run.start() as ctx:
+            assert ctx.get_result("missing") is None
+
+
+class TestRunContextArtifacts:
+    def test_save_dict_as_json(self, run):
+        with run.start() as ctx:
+            path = ctx.save_artifact("data.json", {"key": "value"})
+            assert path.exists()
+            data = json.loads(path.read_text())
+            assert data["key"] == "value"
+
+    def test_save_bytes(self, run):
+        with run.start() as ctx:
+            path = ctx.save_artifact("binary.bin", b"\x00\x01\x02")
+            assert path.exists()
+            assert path.read_bytes() == b"\x00\x01\x02"
+
+    def test_save_text(self, run):
+        with run.start() as ctx:
+            path = ctx.save_artifact("log.txt", "hello world")
+            assert path.exists()
+            assert path.read_text() == "hello world"
+
+    def test_get_artifact_path(self, run):
+        with run.start() as ctx:
+            expected = ctx.artifacts_dir / "file.txt"
+            assert ctx.get_artifact_path("file.txt") == expected
+
+
+class TestRunContextCheckpoint:
+    def test_checkpoint_creates_file(self, run):
+        with run.start() as ctx:
+            ckpt_id = ctx.checkpoint("mid-run")
+            assert ckpt_id.startswith("ckpt_")
+            ckpt_dir = ctx.work_dir / ".ckpt"
+            assert ckpt_dir.exists()
+            assert any(ckpt_dir.iterdir())
+
+
+class TestRunContextParams:
+    def test_params_shortcut(self, experiment):
+        run = experiment.run(parameters={"lr": 1e-4, "batch": 32})
+        with run.start() as ctx:
+            assert ctx.params == {"lr": 1e-4, "batch": 32}
+            assert ctx.params is ctx.run.parameters
+
+    def test_profile_defaults_none(self, run):
+        with run.start() as ctx:
+            assert ctx.config.name is None
+            assert run.metadata.profile is None
+
+
+class TestRunContextGetDataDir:
+    def test_fallback_creates_dir(self, run):
+        with run.start() as ctx:
+            data_dir = ctx.get_data_dir("nonexistent", fallback="data/qm9")
+            assert data_dir.exists()
+            assert data_dir.is_dir()
+            assert isinstance(data_dir, Path)
+
+    def test_no_fallback_raises(self, run):
+        with run.start() as ctx:
+            with pytest.raises(FileNotFoundError, match="not found"):
+                ctx.get_data_dir("nonexistent")
+
+    def test_returns_path_type(self, run):
+        with run.start() as ctx:
+            result = ctx.get_data_dir("missing", fallback="data/test")
+            assert isinstance(result, Path)
+
+
+class TestRunContextErrorDetails:
+    def test_error_log_created(self, experiment):
+        run = experiment.run()
+        try:
+            with run.start() as ctx:
+                raise RuntimeError("detailed error")
+        except RuntimeError:
+            pass
+        # error.txt now lives in the per-execution subdir alongside workflow.json
+        error_txt = ctx.work_dir / "execution" / ctx._execution_id / "error.txt"
+        assert error_txt.exists(), f"error.txt not found at {error_txt}"
+        content = error_txt.read_text()
+        assert "RuntimeError" in content
+        assert "detailed error" in content
+        assert not (ctx.artifacts_dir / "error.txt").exists()
+        assert not (ctx.artifacts_dir / "error.json").exists()
diff --git a/tests/test_workspace/test_workspace.py b/tests/test_workspace/test_workspace.py
new file mode 100644
index 00000000..3927f00e
--- /dev/null
+++ b/tests/test_workspace/test_workspace.py
@@ -0,0 +1,134 @@
+"""Tests for Workspace / Project / Experiment / Run hierarchy."""
+
+import json
+
+from molexp.workspace import Workspace
+
+
+class TestWorkspace:
+    def test_creation_no_side_effects(self, tmp_path):
+        Workspace(root=tmp_path / "new", name="Lab")
+        assert not (tmp_path / "new" / "workspace.json").exists()
+
+    def test_materialize_creates_files(self, tmp_path):
+        ws = Workspace(root=tmp_path, name="Lab")
+        ws.materialize()
+        assert (tmp_path / "workspace.json").exists()
+
+    def test_child_factory_auto_materializes(self, tmp_path):
+        ws = Workspace(root=tmp_path, name="Lab")
+        ws.project("first")
+        assert (tmp_path / "workspace.json").exists()
+
+    def test_load_preserves_metadata(self, workspace):
+        workspace.materialize()
+        loaded = Workspace.load(workspace.root)
+        assert loaded.id == workspace.id
+        assert loaded.name == workspace.name
+
+    def test_from_path_creates_if_missing(self, tmp_path):
+        ws = Workspace.from_path(tmp_path / "auto")
+        ws.materialize()
+        assert ws.root.exists()
+        assert (ws.root / "workspace.json").exists()
+
+    def test_metadata_has_no_child_lists(self, workspace):
+        workspace.materialize()
+        data = json.loads((workspace.root / "workspace.json").read_text())
+        assert "projects" not in data
+
+
+class TestProject:
+    def test_creation(self, workspace):
+        proj = workspace.project("QM9")
+        assert proj.id == "qm9"
+        assert proj.name == "QM9"
+
+    def test_get_by_id(self, workspace, project):
+        found = workspace.get_project(project.id)
+        assert found is not None
+        assert found.id == project.id
+
+    def test_get_by_name_slugified(self, workspace):
+        workspace.project("My Project")
+        found = workspace.get_project("My Project")
+        assert found is not None
+        assert found.id == "my-project"
+
+    def test_list_projects(self, workspace):
+        workspace.project("a")
+        workspace.project("b")
+        assert len(workspace.list_projects()) == 2
+
+    def test_delete(self, workspace, project):
+        workspace.delete_project(project.id)
+        # clear cache after delete (otherwise in-memory stays)
+        workspace._projects_cache.pop(project.id, None)
+        assert workspace.get_project(project.id) is None
+
+    def test_idempotent_returns_same_instance(self, workspace):
+        p1 = workspace.project("dup")
+        p2 = workspace.project("dup")
+        assert p1 is p2
+
+    def test_metadata_has_no_child_lists(self, project):
+        data = json.loads((project.project_dir / "project.json").read_text())
+        assert "experiments" not in data
+        assert "assets" not in data
+
+
+class TestExperiment:
+    def test_creation_with_workflow(self, project):
+        exp = project.experiment(
+            "baseline",
+            workflow_source="train.py",
+            params={"lr": 1e-4},
+            git_commit="abc",
+        )
+        assert exp.metadata.workflow_source == "train.py"
+        assert exp.metadata.parameter_space == {"lr": 1e-4}
+        assert exp.metadata.git_commit == "abc"
+
+    def test_parent_references(self, experiment):
+        assert experiment.project is not None
+        assert experiment.workspace is experiment.project.workspace
+
+    def test_list_experiments(self, project):
+        project.experiment("a")
+        project.experiment("b")
+        assert len(project.list_experiments()) == 2
+
+    def test_get_experiment(self, project, experiment):
+        found = project.get_experiment(experiment.id)
+        assert found is not None
+        assert found.name == experiment.name
+
+    def test_idempotent(self, project):
+        e1 = project.experiment("same")
+        e2 = project.experiment("same")
+        assert e1 is e2
+
+
+class TestRun:
+    def test_creation(self, experiment):
+        run = experiment.run(parameters={"x": 1})
+        assert run.parameters == {"x": 1}
+        assert run.status == "pending"
+
+    def test_workflow_snapshot_auto_captured(self, experiment):
+        run = experiment.run()
+        snap = run.metadata.workflow_snapshot
+        assert snap is not None
+        assert snap.source == "train.py"
+        assert snap.git_commit == "abc123"
+
+    def test_list_runs(self, experiment):
+        experiment.run(parameters={"x": 1})
+        experiment.run(parameters={"x": 2})
+        assert len(experiment.list_runs()) == 2
+
+    def test_reload_from_disk(self, experiment):
+        run = experiment.run(parameters={"x": 42})
+        reloaded = experiment.get_run(run.id)
+        assert reloaded.parameters == {"x": 42}
+        assert reloaded.metadata.workflow_snapshot.source == "train.py"
diff --git a/tests/workflow/compiler/test_core.py b/tests/workflow/compiler/test_core.py
deleted file mode 100644
index f76077ae..00000000
--- a/tests/workflow/compiler/test_core.py
+++ /dev/null
@@ -1,459 +0,0 @@
-"""Tests for WorkflowCompiler type detection and channel allocation."""
-
-import pytest
-from collections.abc import AsyncGenerator
-from pydantic import BaseModel
-
-from molexp.workflow import Workflow, Link
-from molexp.workflow.task import Task, Actor
-from molexp.workflow.compiler import WorkflowCompiler
-from molexp.workflow.execution_type import TaskExecutionType
-
-
-# Test configurations
-class SimpleConfig(BaseModel):
-    value: int = 10
-
-
-class ActorConfig(BaseModel):
-    threshold: float = 0.5
-    count: int = 0
-
-
-# Test tasks
-class BatchTask(Task[SimpleConfig, dict]):
-    """Batch task for testing."""
-    config_type = SimpleConfig
-    outputs = {'result': int}
-
-    def execute(self, ctx=None, **inputs) -> dict:
-        return {'result': self.config.value * 2}
-
-
-class StreamActor(Actor[ActorConfig, dict]):
-    """Actor task for testing."""
-    config_type = ActorConfig
-
-    async def execute(self, ctx=None, **inputs) -> AsyncGenerator[None, dict]:
-        while self.config.count < 5:
-            self.config.count += 1
-            yield
-
-        if ctx:
-            ctx.set_result(self.task_id, {'count': self.config.count})
-        return
-
-
-class AnotherActor(Actor[ActorConfig, dict]):
-    """Another actor for multi-actor tests."""
-    config_type = ActorConfig
-
-    async def execute(self, ctx=None, **inputs) -> AsyncGenerator[None, dict]:
-        for _ in range(3):
-            yield
-        return
-
-
-# Tests for return type inspection
-class TestReturnTypeInspection:
-    """Tests for compiler return type detection."""
-
-    def test_detect_batch_task_type(self):
-        """Test compiler detects BATCH task via dict return type."""
-        compiler = WorkflowCompiler()
-        task = BatchTask()
-
-        task_type = compiler._detect_task_type(task)
-
-        assert task_type == TaskExecutionType.BATCH
-
-    def test_detect_actor_task_type(self):
-        """Test compiler detects ACTOR task via AsyncGenerator return type."""
-        compiler = WorkflowCompiler()
-        actor = StreamActor()
-
-        task_type = compiler._detect_task_type(actor)
-
-        assert task_type == TaskExecutionType.ACTOR
-
-    def test_detect_multiple_task_types(self):
-        """Test compiler correctly identifies mixed task types."""
-        compiler = WorkflowCompiler()
-
-        batch1 = BatchTask()
-        batch2 = BatchTask()
-        actor1 = StreamActor()
-        actor2 = AnotherActor()
-
-        types = {
-            batch1.task_id: compiler._detect_task_type(batch1),
-            batch2.task_id: compiler._detect_task_type(batch2),
-            actor1.task_id: compiler._detect_task_type(actor1),
-            actor2.task_id: compiler._detect_task_type(actor2),
-        }
-
-        assert types[batch1.task_id] == TaskExecutionType.BATCH
-        assert types[batch2.task_id] == TaskExecutionType.BATCH
-        assert types[actor1.task_id] == TaskExecutionType.ACTOR
-        assert types[actor2.task_id] == TaskExecutionType.ACTOR
-
-
-# Tests for TaskExecutionType detection
-class TestTaskExecutionTypeDetection:
-    """Tests for BATCH vs ACTOR classification."""
-
-    def test_batch_execution_type(self):
-        """Test BATCH TaskExecutionType."""
-        assert TaskExecutionType.BATCH.value == "batch"
-
-    def test_actor_execution_type(self):
-        """Test ACTOR TaskExecutionType."""
-        assert TaskExecutionType.ACTOR.value == "actor"
-
-    def test_execution_type_enum_values(self):
-        """Test TaskExecutionType enum has correct values."""
-        types = [t.value for t in TaskExecutionType]
-
-        assert "batch" in types
-        assert "actor" in types
-        assert len(types) == 2
-
-
-# Tests for channel allocation from Links
-class TestChannelAllocation:
-    """Tests for channel allocation logic."""
-
-    def test_allocate_channels_for_actor_link(self):
-        """Test compiler allocates channel for actor-to-actor link."""
-        compiler = WorkflowCompiler()
-
-        actor1 = StreamActor()
-        actor2 = AnotherActor()
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor1, actor2],
-            links=[Link(source=actor1, target=actor2, mapping={'data': 'data'})],
-            name="test_workflow"
-        )
-
-        compiled = compiler.compile(workflow)
-        channels = compiled.get_channels()
-
-        # Should have one channel allocated
-        assert len(channels) == 1
-
-        # Channel should reference source and target
-        channel_id = f"{actor1.task_id}_to_{actor2.task_id}"
-        assert channel_id in channels
-        assert channels[channel_id]['source'] == actor1.task_id
-        assert channels[channel_id]['target'] == actor2.task_id
-
-    def test_no_channels_for_batch_only_workflow(self):
-        """Test compiler does not allocate channels for batch-only workflow."""
-        compiler = WorkflowCompiler()
-
-        batch1 = BatchTask()
-        batch2 = BatchTask()
-
-        workflow = Workflow.from_tasks(
-            tasks=[batch1, batch2],
-            links=[],
-            name="batch_workflow"
-        )
-
-        compiled = compiler.compile(workflow)
-        channels = compiled.get_channels()
-
-        assert len(channels) == 0
-
-    def test_channel_buffer_size_configuration(self):
-        """Test channel buffer_size from Link is preserved."""
-        compiler = WorkflowCompiler()
-
-        actor1 = StreamActor()
-        actor2 = AnotherActor()
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor1, actor2],
-            links=[Link(
-                source=actor1,
-                target=actor2,
-                buffer_size=200,
-                mapping={'out': 'in'}
-            )],
-            name="test_workflow"
-        )
-
-        compiled = compiler.compile(workflow)
-        channels = compiled.get_channels()
-
-        channel_id = f"{actor1.task_id}_to_{actor2.task_id}"
-        assert channels[channel_id]['buffer_size'] == 200
-
-
-# Tests for mapping population order
-class TestMappingPopulation:
-    """Tests for Link.mapping auto-generation and population order."""
-
-    def test_link_mapping_auto_generated_for_actors(self):
-        """Test Link.mapping is auto-generated for actor links."""
-        compiler = WorkflowCompiler()
-
-        actor1 = StreamActor()
-        actor2 = AnotherActor()
-
-        # Link without mapping
-        link = Link(source=actor1, target=actor2)
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor1, actor2],
-            links=[link],
-            name="test_workflow"
-        )
-
-        # Compile (triggers validation which populates mapping)
-        compiler.compile(workflow)
-
-        # Link should now have mapping
-        assert link.mapping is not None
-        assert isinstance(link.mapping, dict)
-
-    def test_mapping_populated_before_channel_allocation(self):
-        """Test validation populates mapping before channel allocation."""
-        compiler = WorkflowCompiler()
-
-        actor1 = StreamActor()
-        actor2 = AnotherActor()
-
-        link = Link(source=actor1, target=actor2)
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor1, actor2],
-            links=[link],
-            name="test_workflow"
-        )
-
-        # Before compilation, mapping may be None
-        original_mapping = link.mapping
-
-        compiled = compiler.compile(workflow)
-        channels = compiled.get_channels()
-
-        # After compilation:
-        # 1. Mapping should be populated
-        assert link.mapping is not None
-
-        # 2. Channel should exist with mapping
-        channel_id = f"{actor1.task_id}_to_{actor2.task_id}"
-        assert channel_id in channels
-        assert 'mapping' in channels[channel_id]
-
-    def test_explicit_mapping_preserved(self):
-        """Test explicit Link.mapping is preserved (not overwritten)."""
-        compiler = WorkflowCompiler()
-
-        actor1 = StreamActor()
-        actor2 = AnotherActor()
-
-        explicit_mapping = {'output_data': 'input_data'}
-        link = Link(source=actor1, target=actor2, mapping=explicit_mapping)
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor1, actor2],
-            links=[link],
-            name="test_workflow"
-        )
-
-        compiled = compiler.compile(workflow)
-
-        # Explicit mapping should be preserved
-        assert link.mapping == explicit_mapping
-
-
-# Tests for cycle detection
-class TestCycleDetection:
-    """Tests for cycle detection in workflows."""
-
-    def test_cycles_allowed_for_actor_workflows(self):
-        """Test cycles are allowed when workflow contains actors."""
-        compiler = WorkflowCompiler()
-
-        actor_a = StreamActor()
-        actor_b = AnotherActor()
-        actor_c = StreamActor()
-
-        # Create feedback loop: A → B → C → A
-        workflow = Workflow.from_tasks(
-            tasks=[actor_a, actor_b, actor_c],
-            links=[
-                Link(source=actor_a, target=actor_b, mapping={'ab': 'ab'}),
-                Link(source=actor_b, target=actor_c, mapping={'bc': 'bc'}),
-                Link(source=actor_c, target=actor_a, mapping={'ca': 'ca'}),
-            ],
-            name="feedback_loop"
-        )
-
-        # Should compile without error
-        compiled = compiler.compile(workflow)
-
-        assert compiled is not None
-        assert len(compiled.get_channels()) == 3
-
-    def test_cycles_rejected_for_batch_only_workflows(self):
-        """Test cycles are rejected for pure batch workflows."""
-        # Note: This requires cycle detection to be implemented in compiler
-        # If not implemented yet, this test documents expected behavior
-
-        compiler = WorkflowCompiler()
-
-        # For batch tasks, we need to properly declare inputs/outputs
-        class BatchWithIO(Task[SimpleConfig, dict]):
-            config_type = SimpleConfig
-            inputs = {'in': int}
-            outputs = {'out': int}
-
-            def execute(self, ctx=None, **inputs) -> dict:
-                return {'out': inputs.get('in', 0) * 2}
-
-        batch_a = BatchWithIO()
-        batch_b = BatchWithIO()
-        batch_c = BatchWithIO()
-
-        # Try to create cycle with batch tasks
-        workflow = Workflow.from_tasks(
-            tasks=[batch_a, batch_b, batch_c],
-            links=[
-                Link(source=batch_a, target=batch_b, mapping={'out': 'in'}),
-                Link(source=batch_b, target=batch_c, mapping={'out': 'in'}),
-                Link(source=batch_c, target=batch_a, mapping={'out': 'in'}),
-            ],
-            name="batch_cycle"
-        )
-
-        # Should raise ValueError for cycle in batch workflow
-        # (if cycle detection is implemented)
-        # with pytest.raises(ValueError, match="cycle"):
-        #     compiler.compile(workflow)
-
-        # For now, this test documents the expected behavior
-        # Uncomment assertion above when cycle detection is implemented
-
-
-# Tests for dynamic channel validation
-class TestDynamicChannelValidation:
-    """Tests that compiler skips channel validation for actors."""
-
-    def test_actors_do_not_require_inputs_outputs(self):
-        """Test actors don't need inputs/outputs declarations."""
-        compiler = WorkflowCompiler()
-
-        # Actors without inputs/outputs declarations
-        actor1 = StreamActor()
-        actor2 = AnotherActor()
-
-        # Should compile without error
-        workflow = Workflow.from_tasks(
-            tasks=[actor1, actor2],
-            links=[Link(source=actor1, target=actor2, mapping={'data': 'data'})],
-            name="dynamic_channels"
-        )
-
-        compiled = compiler.compile(workflow)
-
-        assert compiled is not None
-
-    def test_batch_tasks_require_outputs_for_links(self):
-        """Test batch tasks require outputs declaration for links."""
-        compiler = WorkflowCompiler()
-
-        class BatchNoOutputs(Task[SimpleConfig, dict]):
-            config_type = SimpleConfig
-            # No outputs declared
-
-            def execute(self, ctx=None, **inputs) -> dict:
-                return {}
-
-        class BatchNoInputs(Task[SimpleConfig, dict]):
-            config_type = SimpleConfig
-            # No inputs declared
-
-            def execute(self, ctx=None, **inputs) -> dict:
-                return {}
-
-        batch1 = BatchNoOutputs()
-        batch2 = BatchNoInputs()
-
-        workflow = Workflow.from_tasks(
-            tasks=[batch1, batch2],
-            links=[Link(source=batch1, target=batch2)],
-            name="invalid_batch"
-        )
-
-        # Should raise validation error
-        with pytest.raises(ValueError, match="must declare"):
-            compiler.compile(workflow)
-
-
-# Tests for CompiledWorkflow interface
-class TestCompiledWorkflow:
-    """Tests for CompiledWorkflow high-level API."""
-
-    def test_get_task_types(self):
-        """Test compiled workflow exposes task types."""
-        compiler = WorkflowCompiler()
-
-        batch = BatchTask()
-        actor = StreamActor()
-
-        workflow = Workflow.from_tasks(
-            tasks=[batch, actor],
-            links=[],
-            name="mixed_workflow"
-        )
-
-        compiled = compiler.compile(workflow)
-        task_types = compiled.get_task_types()
-
-        assert task_types[batch.task_id] == TaskExecutionType.BATCH
-        assert task_types[actor.task_id] == TaskExecutionType.ACTOR
-
-    def test_get_channels(self):
-        """Test compiled workflow exposes channel configurations."""
-        compiler = WorkflowCompiler()
-
-        actor1 = StreamActor()
-        actor2 = AnotherActor()
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor1, actor2],
-            links=[Link(source=actor1, target=actor2, mapping={'x': 'y'})],
-            name="channel_workflow"
-        )
-
-        compiled = compiler.compile(workflow)
-        channels = compiled.get_channels()
-
-        assert len(channels) > 0
-        channel_id = f"{actor1.task_id}_to_{actor2.task_id}"
-        assert channel_id in channels
-
-    def test_get_dependency_graph(self):
-        """Test compiled workflow exposes dependency graph."""
-        compiler = WorkflowCompiler()
-
-        batch1 = BatchTask()
-        batch2 = BatchTask()
-
-        workflow = Workflow.from_tasks(
-            tasks=[batch1, batch2],
-            links=[],
-            name="simple_workflow"
-        )
-
-        compiled = compiler.compile(workflow)
-        adj, in_degree = compiled.get_dependency_graph()
-
-        assert isinstance(adj, dict)
-        assert isinstance(in_degree, dict)
-        assert batch1.task_id in adj
-        assert batch2.task_id in adj
diff --git a/tests/workflow/engine/test_engine.py b/tests/workflow/engine/test_engine.py
deleted file mode 100644
index 96052073..00000000
--- a/tests/workflow/engine/test_engine.py
+++ /dev/null
@@ -1,537 +0,0 @@
-"""Tests for WorkflowEngine hybrid execution and hot reconfiguration."""
-
-import asyncio
-import pytest
-from collections.abc import AsyncGenerator
-from pathlib import Path
-from tempfile import TemporaryDirectory
-from pydantic import BaseModel
-
-from molexp.workflow import Workflow, Link
-from molexp.workflow.task import Task, Actor
-from molexp.workflow.engine import WorkflowEngine
-from molexp.workflow.execution_type import TaskExecutionType
-from molexp.workspace import Workspace, RunContext
-
-
-# Test configurations
-class SimpleConfig(BaseModel):
-    value: int = 10
-
-
-class ActorConfig(BaseModel):
-    threshold: float = 0.5
-    count: int = 0
-    max_items: int = 5
-
-
-# Test tasks
-class BatchTask(Task[SimpleConfig, dict]):
-    """Simple batch task."""
-    config_type = SimpleConfig
-
-    def execute(self, ctx=None, **inputs) -> dict:
-        return {'result': self.config.value * 2}
-
-
-class CounterActor(Actor[ActorConfig, dict]):
-    """Simple counting actor."""
-    config_type = ActorConfig
-
-    async def execute(self, ctx=None, **inputs) -> AsyncGenerator[None, dict]:
-        while self.config.count < self.config.max_items:
-            self.config.count += 1
-            yield
-
-        if ctx:
-            ctx.set_result(self.task_id, {'count': self.config.count})
-        return
-
-
-class DataActor(Actor[ActorConfig, dict]):
-    """Actor that processes data via channels."""
-    config_type = ActorConfig
-
-    async def execute(self, ctx=None, **inputs) -> AsyncGenerator[None, dict]:
-        if ctx:
-            for i in range(3):
-                await ctx.emit('output', {'id': i, 'value': i * 10})
-                yield
-
-        if ctx:
-            ctx.set_result(self.task_id, {'sent': 3})
-        return
-
-
-class ProcessorActor(Actor[ActorConfig, dict]):
-    """Actor that receives and processes data."""
-    config_type = ActorConfig
-
-    async def execute(self, ctx=None, **inputs) -> AsyncGenerator[None, dict]:
-        if ctx:
-            processed = []
-            for _ in range(3):
-                data = await asyncio.wait_for(ctx.receive('input'), timeout=2.0)
-                processed.append(data)
-                yield
-
-            ctx.set_result(self.task_id, {'processed': len(processed)})
-        return
-
-
-# Mock workspace/run for testing
-def create_test_run(tmpdir):
-    """Create a test run context."""
-    class MockWorkspace:
-        def __init__(self, root):
-            self.root = Path(root)
-
-    class MockProject:
-        def __init__(self, workspace):
-            self.id = "test_project"
-            self.workspace = workspace
-
-    class MockExperiment:
-        def __init__(self, project):
-            self.id = "test_experiment"
-            self.project = project
-
-    class MockMetadata:
-        def __init__(self):
-            from datetime import datetime
-            self.created_at = datetime.now()
-            self.updated_at = datetime.now()
-
-    class MockRun:
-        def __init__(self, work_dir):
-            from molexp.workflow.status import TaskStatus as RunStatus
-            self.id = "test_run"
-            self.status = RunStatus.PENDING
-            self.parameters = {}
-            self.assets = {}
-            self.metadata = MockMetadata()
-            workspace = MockWorkspace(Path(work_dir))  # Use tmpdir directly, not parent!
-            project = MockProject(workspace)
-            self.experiment = MockExperiment(project)
-
-        def start(self):
-            return RunContext(self)
-
-        def save(self):
-            pass
-
-    return MockRun(tmpdir)
-
-
-# Tests for execution mode detection
-class TestExecutionModeDetection:
-    """Tests for automatic execution mode detection."""
-
-    def test_pure_batch_workflow_detection(self):
-        """Test engine detects pure batch workflow."""
-        batch1 = BatchTask()
-        batch2 = BatchTask()
-
-        workflow = Workflow.from_tasks(
-            tasks=[batch1, batch2],
-            links=[],
-            name="pure_batch"
-        )
-
-        engine = WorkflowEngine(workflow)
-        task_types = engine.compiled.get_task_types()
-
-        # All tasks should be BATCH
-        assert all(t == TaskExecutionType.BATCH for t in task_types.values())
-
-    def test_hybrid_workflow_detection(self):
-        """Test engine detects hybrid workflow (contains actors)."""
-        batch = BatchTask()
-        actor = CounterActor()
-
-        workflow = Workflow.from_tasks(
-            tasks=[batch, actor],
-            links=[],
-            name="hybrid"
-        )
-
-        engine = WorkflowEngine(workflow)
-        task_types = engine.compiled.get_task_types()
-
-        # Should have both BATCH and ACTOR
-        assert TaskExecutionType.BATCH in task_types.values()
-        assert TaskExecutionType.ACTOR in task_types.values()
-
-    def test_pure_actor_workflow_detection(self):
-        """Test engine detects pure actor workflow."""
-        actor1 = CounterActor()
-        actor2 = DataActor()
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor1, actor2],
-            links=[],
-            name="pure_actor"
-        )
-
-        engine = WorkflowEngine(workflow)
-        task_types = engine.compiled.get_task_types()
-
-        # All tasks should be ACTOR
-        assert all(t == TaskExecutionType.ACTOR for t in task_types.values())
-
-
-# Tests for pure batch fast path
-class TestPureBatchFastPath:
-    """Tests for pure batch execution optimization."""
-
-    def test_pure_batch_executes_successfully(self):
-        """Test pure batch workflow executes via fast path."""
-        with TemporaryDirectory() as tmpdir:
-            batch = BatchTask(value=21)
-
-            workflow = Workflow.from_tasks(
-                tasks=[batch],
-                links=[],
-                name="single_batch"
-            )
-
-            engine = WorkflowEngine(workflow)
-            run = create_test_run(tmpdir)
-
-            with run.start() as run_ctx:
-                results = engine.execute(run_context=run_ctx)
-
-            assert batch.task_id in results
-            assert results[batch.task_id]['result'] == 42
-
-
-# Tests for actor concurrent execution
-class TestActorConcurrentExecution:
-    """Tests for concurrent actor execution."""
-
-    def test_single_actor_executes(self):
-        """Test single actor executes successfully."""
-        with TemporaryDirectory() as tmpdir:
-            actor = CounterActor(max_items=3)
-
-            workflow = Workflow.from_tasks(
-                tasks=[actor],
-                links=[],
-                name="single_actor"
-            )
-
-            engine = WorkflowEngine(workflow)
-            run = create_test_run(tmpdir)
-
-            with run.start() as run_ctx:
-                results = engine.execute(run_context=run_ctx)
-
-            assert actor.task_id in results
-            assert results[actor.task_id]['count'] == 3
-
-    def test_multiple_actors_execute_concurrently(self):
-        """Test multiple actors execute concurrently."""
-        with TemporaryDirectory() as tmpdir:
-            actor1 = CounterActor(max_items=3)
-            actor2 = CounterActor(max_items=5)
-            actor3 = CounterActor(max_items=2)
-
-            workflow = Workflow.from_tasks(
-                tasks=[actor1, actor2, actor3],
-                links=[],
-                name="multi_actor"
-            )
-
-            engine = WorkflowEngine(workflow)
-            run = create_test_run(tmpdir)
-
-            with run.start() as run_ctx:
-                results = engine.execute(run_context=run_ctx)
-
-            # All actors should complete
-            assert len(results) == 3
-            assert results[actor1.task_id]['count'] == 3
-            assert results[actor2.task_id]['count'] == 5
-            assert results[actor3.task_id]['count'] == 2
-
-    def test_actors_with_message_passing(self):
-        """Test actors communicate via channels."""
-        with TemporaryDirectory() as tmpdir:
-            sender = DataActor()
-            receiver = ProcessorActor()
-
-            workflow = Workflow.from_tasks(
-                tasks=[sender, receiver],
-                links=[Link(
-                    source=sender,
-                    target=receiver,
-                    mapping={'output': 'input'}
-                )],
-                name="actor_pipeline"
-            )
-
-            engine = WorkflowEngine(workflow)
-            run = create_test_run(tmpdir)
-
-            with run.start() as run_ctx:
-                results = engine.execute(run_context=run_ctx)
-
-            # Both actors should complete
-            assert sender.task_id in results
-            assert receiver.task_id in results
-            assert results[sender.task_id]['sent'] == 3
-            assert results[receiver.task_id]['processed'] == 3
-
-
-# Tests for actor failure propagation
-class TestActorFailurePropagation:
-    """Tests for actor failure handling."""
-
-    def test_actor_exception_captured(self):
-        """Test actor exceptions are captured."""
-        class FailingActor(Actor[ActorConfig, dict]):
-            config_type = ActorConfig
-
-            async def execute(self, ctx=None, **inputs) -> AsyncGenerator[None, dict]:
-                yield
-                raise ValueError("Test failure")
-
-        with TemporaryDirectory() as tmpdir:
-            actor = FailingActor()
-
-            workflow = Workflow.from_tasks(
-                tasks=[actor],
-                links=[],
-                name="failing_actor"
-            )
-
-            engine = WorkflowEngine(workflow)
-            run = create_test_run(tmpdir)
-
-            with run.start() as run_ctx:
-                # Engine should handle failure gracefully
-                results = engine.execute(run_context=run_ctx)
-
-            # Check that failure was recorded
-            # (Exact behavior depends on engine implementation)
-
-
-# Tests for channel creation and registration
-class TestChannelManagement:
-    """Tests for channel creation and registration."""
-
-    def test_channels_created_for_actor_links(self):
-        """Test channels are created for actor-to-actor links."""
-        with TemporaryDirectory() as tmpdir:
-            actor1 = DataActor()
-            actor2 = ProcessorActor()
-
-            workflow = Workflow.from_tasks(
-                tasks=[actor1, actor2],
-                links=[Link(
-                    source=actor1,
-                    target=actor2,
-                    mapping={'output': 'input'},
-                    buffer_size=50
-                )],
-                name="channel_test"
-            )
-
-            engine = WorkflowEngine(workflow)
-            channels = engine.compiled.get_channels()
-
-            # Should have one channel
-            assert len(channels) == 1
-
-            channel_id = f"{actor1.task_id}_to_{actor2.task_id}"
-            assert channel_id in channels
-            assert channels[channel_id]['buffer_size'] == 50
-
-    def test_channel_registration_in_context(self):
-        """Test channels are registered in RunContext."""
-        with TemporaryDirectory() as tmpdir:
-            sender = DataActor()
-            receiver = ProcessorActor()
-
-            workflow = Workflow.from_tasks(
-                tasks=[sender, receiver],
-                links=[Link(
-                    source=sender,
-                    target=receiver,
-                    mapping={'output': 'input'}
-                )],
-                name="registration_test"
-            )
-
-            engine = WorkflowEngine(workflow)
-            run = create_test_run(tmpdir)
-
-            with run.start() as run_ctx:
-                # Execute workflow (channels should be registered)
-                engine.execute(run_context=run_ctx)
-
-                # After execution, can't directly check channels
-                # but the fact that message passing worked proves registration
-
-
-# Tests for result capture from ctx.set_result()
-class TestResultCapture:
-    """Tests for capturing actor results via ctx.set_result()."""
-
-    def test_actor_result_captured(self):
-        """Test actor result is captured via ctx.set_result()."""
-        with TemporaryDirectory() as tmpdir:
-            actor = CounterActor(max_items=10)
-
-            workflow = Workflow.from_tasks(
-                tasks=[actor],
-                links=[],
-                name="result_capture"
-            )
-
-            engine = WorkflowEngine(workflow)
-            run = create_test_run(tmpdir)
-
-            with run.start() as run_ctx:
-                results = engine.execute(run_context=run_ctx)
-
-            # Result should be captured
-            assert actor.task_id in results
-            assert 'count' in results[actor.task_id]
-            assert results[actor.task_id]['count'] == 10
-
-    def test_multiple_actor_results_captured(self):
-        """Test results from multiple actors are all captured."""
-        with TemporaryDirectory() as tmpdir:
-            actor1 = CounterActor(max_items=5)
-            actor2 = CounterActor(max_items=7)
-            actor3 = CounterActor(max_items=3)
-
-            workflow = Workflow.from_tasks(
-                tasks=[actor1, actor2, actor3],
-                links=[],
-                name="multi_result"
-            )
-
-            engine = WorkflowEngine(workflow)
-            run = create_test_run(tmpdir)
-
-            with run.start() as run_ctx:
-                results = engine.execute(run_context=run_ctx)
-
-            # All results should be captured
-            assert len(results) == 3
-            assert all('count' in r for r in results.values())
-
-
-# Tests for hot reconfiguration
-class TestHotReconfiguration:
-    """Tests for update_actor_config() method."""
-
-    def test_update_actor_config_basic(self):
-        """Test update_actor_config() updates actor config."""
-        actor = CounterActor(max_items=10)
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor],
-            links=[],
-            name="reconfig_test"
-        )
-
-        engine = WorkflowEngine(workflow)
-
-        # Update config
-        engine.update_actor_config(actor.task_id, {'max_items': 20})
-
-        # Config should be updated
-        assert actor.config.max_items == 20
-
-    def test_update_actor_config_validation(self):
-        """Test update_actor_config() validates new config."""
-        actor = CounterActor(max_items=10)
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor],
-            links=[],
-            name="validation_test"
-        )
-
-        engine = WorkflowEngine(workflow)
-
-        # Try invalid config (wrong type) - should raise ValidationError
-        from pydantic import ValidationError
-        with pytest.raises(ValidationError):
-            engine.update_actor_config(actor.task_id, {'max_items': "not_an_int"})
-
-    def test_update_actor_config_invalid_actor_id(self):
-        """Test update_actor_config() raises KeyError for invalid ID."""
-        actor = CounterActor()
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor],
-            links=[],
-            name="invalid_id_test"
-        )
-
-        engine = WorkflowEngine(workflow)
-
-        # Try non-existent actor
-        with pytest.raises(KeyError, match="not found"):
-            engine.update_actor_config('nonexistent_actor', {'max_items': 5})
-
-    def test_update_actor_config_not_an_actor(self):
-        """Test update_actor_config() raises TypeError for non-actor task."""
-        batch = BatchTask()
-
-        workflow = Workflow.from_tasks(
-            tasks=[batch],
-            links=[],
-            name="not_actor_test"
-        )
-
-        engine = WorkflowEngine(workflow)
-
-        # Try to update batch task (not an actor)
-        with pytest.raises(TypeError, match="not an Actor"):
-            engine.update_actor_config(batch.task_id, {'value': 100})
-
-    def test_update_actor_config_partial_update(self):
-        """Test update_actor_config() supports partial updates."""
-        actor = CounterActor(threshold=0.5, count=0, max_items=10)
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor],
-            links=[],
-            name="partial_update_test"
-        )
-
-        engine = WorkflowEngine(workflow)
-
-        # Update only one field
-        engine.update_actor_config(actor.task_id, {'threshold': 0.8})
-
-        # Only threshold should change
-        assert actor.config.threshold == 0.8
-        assert actor.config.max_items == 10  # Unchanged
-        assert actor.config.count == 0  # Unchanged
-
-    def test_update_actor_config_multiple_fields(self):
-        """Test update_actor_config() can update multiple fields."""
-        actor = CounterActor(threshold=0.5, max_items=10)
-
-        workflow = Workflow.from_tasks(
-            tasks=[actor],
-            links=[],
-            name="multi_field_test"
-        )
-
-        engine = WorkflowEngine(workflow)
-
-        # Update multiple fields
-        engine.update_actor_config(actor.task_id, {
-            'threshold': 0.9,
-            'max_items': 20
-        })
-
-        assert actor.config.threshold == 0.9
-        assert actor.config.max_items == 20
diff --git a/tests/workflow/test_link.py b/tests/workflow/test_link.py
deleted file mode 100644
index 3020ea4a..00000000
--- a/tests/workflow/test_link.py
+++ /dev/null
@@ -1,355 +0,0 @@
-"""Tests for Link class and channel mapping."""
-
-import pytest
-from pydantic import BaseModel, ValidationError
-
-from molexp.workflow import Link
-from molexp.workflow.task import Task, Actor
-from collections.abc import AsyncGenerator
-
-
-# Test configurations and tasks
-class SimpleConfig(BaseModel):
-    value: int = 10
-
-
-class SimpleTask(Task[SimpleConfig, dict]):
-    config_type = SimpleConfig
-
-    def execute(self, ctx=None, **inputs) -> dict:
-        return {}
-
-
-class SimpleActor(Actor[SimpleConfig, dict]):
-    config_type = SimpleConfig
-
-    async def execute(self, ctx=None, **inputs) -> AsyncGenerator[None, dict]:
-        yield
-        return
-
-
-# Tests for Link instantiation
-class TestLinkInstantiation:
-    """Tests for Link creation and validation."""
-
-    def test_link_with_string_task_ids(self):
-        """Test Link accepts string task IDs."""
-        link = Link(source='task_a', target='task_b')
-
-        assert link.source == 'task_a'
-        assert link.target == 'task_b'
-
-    def test_link_with_task_instances(self):
-        """Test Link accepts Task instances and extracts IDs."""
-        task_a = SimpleTask()
-        task_b = SimpleTask()
-
-        link = Link(source=task_a, target=task_b)
-
-        assert link.source == task_a.task_id
-        assert link.target == task_b.task_id
-
-    def test_link_with_actor_instances(self):
-        """Test Link accepts Actor instances."""
-        actor_a = SimpleActor()
-        actor_b = SimpleActor()
-
-        link = Link(source=actor_a, target=actor_b)
-
-        assert link.source == actor_a.task_id
-        assert link.target == actor_b.task_id
-
-    def test_link_with_mixed_types(self):
-        """Test Link accepts mix of Task instances and strings."""
-        task_a = SimpleTask()
-
-        link = Link(source=task_a, target='task_b')
-
-        assert link.source == task_a.task_id
-        assert link.target == 'task_b'
-
-    def test_link_requires_source_and_target(self):
-        """Test Link requires both source and target."""
-        with pytest.raises(ValidationError):
-            Link(source='task_a')  # Missing target
-
-        with pytest.raises(ValidationError):
-            Link(target='task_b')  # Missing source
-
-
-# Tests for Link mapping
-class TestLinkMapping:
-    """Tests for Link.mapping attribute."""
-
-    def test_link_mapping_defaults_to_none(self):
-        """Test Link.mapping defaults to None."""
-        link = Link(source='a', target='b')
-
-        assert link.mapping is None
-
-    def test_link_with_explicit_mapping(self):
-        """Test Link accepts explicit mapping."""
-        mapping = {'output_data': 'input_data'}
-        link = Link(source='a', target='b', mapping=mapping)
-
-        assert link.mapping == mapping
-
-    def test_link_mapping_is_dict(self):
-        """Test Link.mapping must be dict."""
-        link = Link(
-            source='a',
-            target='b',
-            mapping={'out': 'in', 'results': 'data'}
-        )
-
-        assert isinstance(link.mapping, dict)
-        assert 'out' in link.mapping
-        assert link.mapping['out'] == 'in'
-
-    def test_link_mapping_can_be_empty_dict(self):
-        """Test Link.mapping can be empty dict."""
-        link = Link(source='a', target='b', mapping={})
-
-        assert link.mapping == {}
-
-
-# Tests for mapping auto-generation
-class TestMappingAutoGeneration:
-    """Tests for automatic mapping generation (integration with compiler)."""
-
-    def test_link_mapping_populated_by_compiler(self):
-        """Test Link.mapping is populated during compilation.
-
-        Note: This is tested more thoroughly in compiler tests.
-        This test documents that Links can start with mapping=None
-        and be populated later.
-        """
-        link = Link(source='actor_a', target='actor_b')
-
-        # Initially None
-        assert link.mapping is None
-
-        # After compilation, compiler would populate this
-        # Simulating compiler action:
-        link.mapping = {'actora_to_actorb': 'actora_to_actorb'}
-
-        assert link.mapping is not None
-        assert isinstance(link.mapping, dict)
-
-
-# Tests for mapping serialization
-class TestMappingSerialization:
-    """Tests for Link serialization with mapping."""
-
-    def test_link_serialization_includes_mapping(self):
-        """Test Link can be serialized to dict."""
-        link = Link(
-            source='task_a',
-            target='task_b',
-            mapping={'data': 'input'},
-            buffer_size=150
-        )
-
-        serialized = link.model_dump()
-
-        assert isinstance(serialized, dict)
-        assert serialized['source'] == 'task_a'
-        assert serialized['target'] == 'task_b'
-        assert serialized['mapping'] == {'data': 'input'}
-        assert serialized['buffer_size'] == 150
-
-    def test_link_deserialization(self):
-        """Test Link can be reconstructed from dict."""
-        data = {
-            'source': 'actor_x',
-            'target': 'actor_y',
-            'mapping': {'output': 'input'},
-            'buffer_size': 200
-        }
-
-        link = Link(**data)
-
-        assert link.source == 'actor_x'
-        assert link.target == 'actor_y'
-        assert link.mapping == {'output': 'input'}
-        assert link.buffer_size == 200
-
-    def test_link_serialization_with_none_mapping(self):
-        """Test Link serialization handles None mapping."""
-        link = Link(source='a', target='b')
-
-        serialized = link.model_dump()
-
-        assert 'mapping' in serialized
-        assert serialized['mapping'] is None
-
-
-# Tests for buffer_size
-class TestLinkBufferSize:
-    """Tests for Link.buffer_size attribute."""
-
-    def test_link_buffer_size_defaults_to_100(self):
-        """Test Link.buffer_size defaults to 100."""
-        link = Link(source='a', target='b')
-
-        assert link.buffer_size == 100
-
-    def test_link_with_custom_buffer_size(self):
-        """Test Link accepts custom buffer_size."""
-        link = Link(source='a', target='b', buffer_size=500)
-
-        assert link.buffer_size == 500
-
-    def test_link_buffer_size_used_for_actors(self):
-        """Test buffer_size is meaningful for actor channels."""
-        actor_a = SimpleActor()
-        actor_b = SimpleActor()
-
-        # Create link with specific buffer size
-        link = Link(
-            source=actor_a,
-            target=actor_b,
-            buffer_size=250,
-            mapping={'out': 'in'}
-        )
-
-        # Buffer size should be preserved
-        assert link.buffer_size == 250
-
-
-# Tests for channels attribute
-class TestLinkChannels:
-    """Tests for Link.channels attribute."""
-
-    def test_link_channels_defaults_to_none(self):
-        """Test Link.channels defaults to None."""
-        link = Link(source='a', target='b')
-
-        assert link.channels is None
-
-    def test_link_with_explicit_channels(self):
-        """Test Link accepts explicit channels mapping."""
-        channels = {'output_channel': 'input_channel'}
-        link = Link(source='a', target='b', channels=channels)
-
-        assert link.channels == channels
-
-    def test_link_channels_is_dict(self):
-        """Test Link.channels must be dict."""
-        link = Link(
-            source='a',
-            target='b',
-            channels={'out': 'in', 'error': 'error_handler'}
-        )
-
-        assert isinstance(link.channels, dict)
-
-
-# Tests for status attribute
-class TestLinkStatus:
-    """Tests for Link.status attribute."""
-
-    def test_link_status_defaults_to_pending(self):
-        """Test Link.status defaults to 'pending'."""
-        link = Link(source='a', target='b')
-
-        assert link.status == "pending"
-
-    def test_link_with_custom_status(self):
-        """Test Link accepts custom status."""
-        link = Link(source='a', target='b', status='active')
-
-        assert link.status == 'active'
-
-
-# Tests for field validation
-class TestLinkFieldValidation:
-    """Tests for Link field validation."""
-
-    def test_link_extract_task_id_validator(self):
-        """Test extract_task_id validator works correctly."""
-        # With Task instance
-        task = SimpleTask()
-        link1 = Link(source=task, target='b')
-        assert link1.source == task.task_id
-
-        # With string
-        link2 = Link(source='task_id', target='b')
-        assert link2.source == 'task_id'
-
-        # With Actor instance
-        actor = SimpleActor()
-        link3 = Link(source=actor, target='b')
-        assert link3.source == actor.task_id
-
-
-# Tests for Link equality and hashing
-class TestLinkEquality:
-    """Tests for Link comparison."""
-
-    def test_links_with_same_values_are_equal(self):
-        """Test Links with same values are equal."""
-        link1 = Link(source='a', target='b', mapping={'x': 'y'})
-        link2 = Link(source='a', target='b', mapping={'x': 'y'})
-
-        # Pydantic models use value equality
-        assert link1.source == link2.source
-        assert link1.target == link2.target
-        assert link1.mapping == link2.mapping
-
-
-# Tests for Link documentation fields
-class TestLinkDocumentation:
-    """Tests that Link has proper documentation."""
-
-    def test_link_has_docstring(self):
-        """Test Link class has docstring."""
-        assert Link.__doc__ is not None
-        assert len(Link.__doc__) > 0
-
-    def test_link_field_info(self):
-        """Test Link fields have descriptions."""
-        # Pydantic provides field info
-        schema = Link.model_json_schema()
-
-        assert 'properties' in schema
-        assert 'source' in schema['properties']
-        assert 'target' in schema['properties']
-        assert 'mapping' in schema['properties']
-        assert 'buffer_size' in schema['properties']
-
-
-# Tests for Link usage in workflows
-class TestLinkWorkflowUsage:
-    """Tests for Link usage patterns in workflows."""
-
-    def test_link_list_for_workflow(self):
-        """Test multiple Links can be used in workflow."""
-        task_a = SimpleTask()
-        task_b = SimpleTask()
-        task_c = SimpleTask()
-
-        links = [
-            Link(source=task_a, target=task_b),
-            Link(source=task_b, target=task_c),
-        ]
-
-        assert len(links) == 2
-        assert all(isinstance(link, Link) for link in links)
-
-    def test_link_with_feedback_loop(self):
-        """Test Link can represent feedback loop."""
-        actor_a = SimpleActor()
-        actor_b = SimpleActor()
-        actor_c = SimpleActor()
-
-        # Create cycle: A → B → C → A
-        links = [
-            Link(source=actor_a, target=actor_b, mapping={'ab': 'ab'}),
-            Link(source=actor_b, target=actor_c, mapping={'bc': 'bc'}),
-            Link(source=actor_c, target=actor_a, mapping={'ca': 'ca'}),
-        ]
-
-        # Links form a cycle
-        assert links[0].source == actor_a.task_id
-        assert links[2].target == actor_a.task_id
diff --git a/tests/workflow/test_task.py b/tests/workflow/test_task.py
deleted file mode 100644
index fd6b5a94..00000000
--- a/tests/workflow/test_task.py
+++ /dev/null
@@ -1,275 +0,0 @@
-"""Tests for Actor base class and Task abstraction."""
-
-import asyncio
-import pytest
-from collections.abc import AsyncGenerator
-from pydantic import BaseModel, ValidationError
-
-from molexp.workflow.task import Task, Actor, TaskConfig
-
-
-# Test configurations
-class SimpleConfig(BaseModel):
-    """Simple config for testing."""
-    value: int = 10
-    name: str = "test"
-
-
-class StatefulConfig(BaseModel):
-    """Config with state fields for config-as-state pattern."""
-    threshold: float = 0.5
-    count: int = 0
-    items_processed: int = 0
-
-
-# Test tasks
-class SimpleTask(Task[SimpleConfig, dict]):
-    """Simple batch task for testing."""
-    config_type = SimpleConfig
-
-    def execute(self, ctx=None, **inputs) -> dict:
-        return {"result": self.config.value * 2}
-
-
-class SimpleActor(Actor[StatefulConfig, dict]):
-    """Simple actor for testing."""
-    config_type = StatefulConfig
-
-    async def execute(self, ctx=None, **inputs) -> AsyncGenerator[None, dict]:
-        """Execute actor with config-as-state pattern."""
-        for i in range(5):
-            self.config.items_processed += 1
-            if i > self.config.threshold:
-                self.config.count += 1
-            yield
-
-        if ctx:
-            ctx.set_result(self.task_id, {
-                'count': self.config.count,
-                'items_processed': self.config.items_processed
-            })
-        return
-
-
-# Tests for Task base class
-class TestTask:
-    """Tests for Task base class."""
-
-    def test_task_instantiation_with_valid_config(self):
-        """Test Task instantiation with valid config."""
-        task = SimpleTask(value=42, name="test_task")
-
-        assert task.config.value == 42
-        assert task.config.name == "test_task"
-        assert task.task_id.startswith("SimpleTask_")
-
-    def test_task_instantiation_with_invalid_config(self):
-        """Test Task instantiation fails with invalid config."""
-        with pytest.raises(ValidationError):
-            SimpleTask(value="not_an_int")
-
-    def test_task_auto_generates_unique_id(self):
-        """Test each task gets unique auto-generated ID."""
-        task1 = SimpleTask()
-        task2 = SimpleTask()
-
-        assert task1.task_id != task2.task_id
-        assert task1.task_id.startswith("SimpleTask_")
-        assert task2.task_id.startswith("SimpleTask_")
-
-    def test_task_execute_returns_dict(self):
-        """Test Task execute() returns dict."""
-        task = SimpleTask(value=10)
-        result = task.execute()
-
-        assert isinstance(result, dict)
-        assert result["result"] == 20
-
-    def test_task_callable_interface(self):
-        """Test Task __call__ interface."""
-        task = SimpleTask(value=15)
-        result = task(input_value=42)
-
-        assert isinstance(result, dict)
-        assert result["result"] == 30
-
-    def test_task_dump_serialization(self):
-        """Test Task.dump() serializes config."""
-        task = SimpleTask(value=99, name="serialize_test")
-        dumped = task.dump()
-
-        assert isinstance(dumped, dict)
-        assert dumped["value"] == 99
-        assert dumped["name"] == "serialize_test"
-
-    def test_task_get_config_schema(self):
-        """Test Task.get_config_schema() returns JSON schema."""
-        schema = SimpleTask.get_config_schema()
-
-        assert isinstance(schema, dict)
-        assert "properties" in schema
-        assert "value" in schema["properties"]
-
-
-# Tests for Actor base class
-class TestActor:
-    """Tests for Actor base class."""
-
-    def test_actor_instantiation_with_config(self):
-        """Test Actor instantiation with config."""
-        actor = SimpleActor(threshold=0.3, count=0, items_processed=0)
-
-        assert actor.config.threshold == 0.3
-        assert actor.config.count == 0
-        assert actor.config.items_processed == 0
-        assert actor.task_id.startswith("SimpleActor_")
-
-    def test_actor_is_task_subclass(self):
-        """Test Actor is a Task subclass."""
-        actor = SimpleActor()
-
-        assert isinstance(actor, Task)
-        assert isinstance(actor, Actor)
-
-    @pytest.mark.asyncio
-    async def test_actor_returns_async_generator(self):
-        """Test Actor.execute() returns AsyncGenerator."""
-        actor = SimpleActor(threshold=2.0)
-
-        gen = actor.execute()
-
-        assert isinstance(gen, AsyncGenerator)
-
-    @pytest.mark.asyncio
-    async def test_actor_async_generator_protocol(self):
-        """Test Actor AsyncGenerator can be iterated."""
-        actor = SimpleActor(threshold=2.0)
-
-        gen = actor.execute()
-        iterations = 0
-
-        async for _ in gen:
-            iterations += 1
-
-        assert iterations == 5
-
-    @pytest.mark.asyncio
-    async def test_actor_config_as_state_pattern(self):
-        """Test Actor config-as-state pattern."""
-        actor = SimpleActor(threshold=2.0, count=0, items_processed=0)
-
-        gen = actor.execute()
-        async for _ in gen:
-            pass
-
-        # State stored in config
-        assert actor.config.items_processed == 5
-        assert actor.config.count == 2  # items 3, 4 are > 2.0 (0-indexed: 3.0, 4.0)
-
-    @pytest.mark.asyncio
-    async def test_actor_config_changes_during_execution(self):
-        """Test Actor reflects config changes during execution."""
-        actor = SimpleActor(threshold=5.0)  # High threshold, no items pass
-
-        gen = actor.execute()
-
-        # Process 2 iterations
-        await gen.__anext__()
-        await gen.__anext__()
-
-        # Update config (simulating hot reconfiguration)
-        actor.config.threshold = 0.0  # Now all items should pass
-
-        # Continue execution
-        async for _ in gen:
-            pass
-
-        # Count should reflect new threshold
-        assert actor.config.count > 0
-
-    @pytest.mark.asyncio
-    async def test_actor_set_result_via_context(self):
-        """Test Actor uses ctx.set_result() for final results."""
-        class MockContext:
-            def __init__(self):
-                self.results = {}
-
-            def set_result(self, task_id, result):
-                self.results[task_id] = result
-
-        actor = SimpleActor(threshold=2.0)
-        ctx = MockContext()
-
-        gen = actor.execute(ctx=ctx)
-        async for _ in gen:
-            pass
-
-        # Result should be set via context
-        assert actor.task_id in ctx.results
-        assert ctx.results[actor.task_id]['items_processed'] == 5
-        assert ctx.results[actor.task_id]['count'] == 2
-
-
-# Tests for Task vs Actor differentiation
-class TestTaskActorDifferentiation:
-    """Tests for distinguishing Task from Actor."""
-
-    def test_task_and_actor_have_different_execute_signatures(self):
-        """Test Task and Actor have different execute() signatures."""
-        import inspect
-
-        task = SimpleTask()
-        actor = SimpleActor()
-
-        task_sig = inspect.signature(task.execute)
-        actor_sig = inspect.signature(actor.execute)
-
-        # Both should have signatures, but return annotations differ
-        assert task_sig.return_annotation == dict
-        # Actor return annotation should be AsyncGenerator
-        from typing import get_origin
-        assert get_origin(actor_sig.return_annotation) is AsyncGenerator
-
-    def test_actor_instance_check(self):
-        """Test isinstance() distinguishes Actor from Task."""
-        task = SimpleTask()
-        actor = SimpleActor()
-
-        assert isinstance(task, Task)
-        assert not isinstance(task, Actor)
-
-        assert isinstance(actor, Task)
-        assert isinstance(actor, Actor)
-
-
-# Removed TestActorDeprecatedMethods - methods removed in refactoring
-
-
-# Tests for TaskConfig serialization model
-class TestTaskConfig:
-    """Tests for TaskConfig serialization model."""
-
-    def test_task_config_instantiation(self):
-        """Test TaskConfig can be instantiated."""
-        config = TaskConfig(
-            task_id="task_123",
-            task_type="SimpleTask",
-            config={"value": 42, "name": "test"},
-            status="pending"
-        )
-
-        assert config.task_id == "task_123"
-        assert config.task_type == "SimpleTask"
-        assert config.config["value"] == 42
-        assert config.status == "pending"
-
-    def test_task_config_default_values(self):
-        """Test TaskConfig default values."""
-        config = TaskConfig(
-            task_id="task_123",
-            task_type="SimpleTask",
-            config={}
-        )
-
-        assert config.status == "pending"
-        assert config.phase is None
diff --git a/tests/workspace/test_run_context_hybrid.py b/tests/workspace/test_run_context_hybrid.py
deleted file mode 100644
index e9c7fd10..00000000
--- a/tests/workspace/test_run_context_hybrid.py
+++ /dev/null
@@ -1,401 +0,0 @@
-"""Tests for RunContext message passing in hybrid mode."""
-
-import asyncio
-import pytest
-from pathlib import Path
-from tempfile import TemporaryDirectory
-
-from molexp.workspace import Workspace, RunContext, Context
-
-
-# Mock classes for testing
-class MockWorkspace:
-    def __init__(self, root):
-        self.root = Path(root)
-
-class MockProject:
-    def __init__(self, workspace):
-        self.id = "test_project"
-        self.workspace = workspace
-
-class MockExperiment:
-    def __init__(self, project):
-        self.id = "test_experiment"
-        self.project = project
-
-class MockMetadata:
-    def __init__(self):
-        from datetime import datetime
-        self.created_at = datetime.now()
-        self.updated_at = datetime.now()
-
-class MockRun:
-    """Mock Run for testing."""
-    def __init__(self, work_dir):
-        from molexp.workflow.status import TaskStatus as RunStatus
-        self.id = "test_run"
-        self.status = RunStatus.PENDING
-        self.parameters = {}
-        self.assets = {}
-        self.metadata = MockMetadata()
-        workspace = MockWorkspace(Path(work_dir))  # Use tmpdir directly, not parent!
-        project = MockProject(workspace)
-        self.experiment = MockExperiment(project)
-
-    def save(self):
-        pass
-
-
-# Tests for emit() and receive()
-class TestMessagePassing:
-    """Tests for ctx.emit() and ctx.receive()."""
-
-    @pytest.mark.asyncio
-    async def test_emit_and_receive_basic(self):
-        """Test basic emit and receive functionality."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            # Create a channel
-            queue = asyncio.Queue(maxsize=10)
-            ctx._register_channel('test_channel', queue)
-
-            # Emit message
-            await ctx.emit('test_channel', {'data': 42})
-
-            # Receive message
-            received = await ctx.receive('test_channel')
-
-            assert received == {'data': 42}
-
-    @pytest.mark.asyncio
-    async def test_emit_multiple_messages(self):
-        """Test emitting multiple messages."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            queue = asyncio.Queue(maxsize=10)
-            ctx._register_channel('data', queue)
-
-            # Emit multiple messages
-            messages = [{'id': i, 'value': i * 10} for i in range(5)]
-            for msg in messages:
-                await ctx.emit('data', msg)
-
-            # Receive all messages
-            received = []
-            for _ in range(5):
-                msg = await ctx.receive('data')
-                received.append(msg)
-
-            assert received == messages
-
-    @pytest.mark.asyncio
-    async def test_receive_blocks_when_empty(self):
-        """Test receive() blocks when channel is empty."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            queue = asyncio.Queue(maxsize=10)
-            ctx._register_channel('empty_channel', queue)
-
-            # Try to receive with timeout
-            with pytest.raises(asyncio.TimeoutError):
-                await asyncio.wait_for(
-                    ctx.receive('empty_channel'),
-                    timeout=0.1
-                )
-
-    @pytest.mark.asyncio
-    async def test_emit_blocks_when_full(self):
-        """Test emit() blocks when channel is full (backpressure)."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            # Create channel with small buffer
-            queue = asyncio.Queue(maxsize=2)
-            ctx._register_channel('small_channel', queue)
-
-            # Fill the channel
-            await ctx.emit('small_channel', 'msg1')
-            await ctx.emit('small_channel', 'msg2')
-
-            # Next emit should block
-            emit_task = asyncio.create_task(
-                ctx.emit('small_channel', 'msg3')
-            )
-
-            # Give it time to try emitting
-            await asyncio.sleep(0.1)
-
-            # Task should not be done (blocked)
-            assert not emit_task.done()
-
-            # Receive one message to make space
-            await ctx.receive('small_channel')
-
-            # Now emit should complete
-            await asyncio.wait_for(emit_task, timeout=0.5)
-            assert emit_task.done()
-
-
-# Tests for channel not found errors
-class TestChannelErrors:
-    """Tests for channel error handling."""
-
-    @pytest.mark.asyncio
-    async def test_emit_channel_not_found(self):
-        """Test emit() silently drops messages to non-existent channels."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            # Emit to non-existent channel should not raise (message is dropped)
-            await ctx.emit('nonexistent', {'data': 42})
-            # No exception raised - message was silently dropped
-
-    @pytest.mark.asyncio
-    async def test_receive_channel_not_found(self):
-        """Test receive() raises KeyError for non-existent channel."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            with pytest.raises(KeyError, match="Channel 'nonexistent' not found"):
-                await ctx.receive('nonexistent')
-
-    @pytest.mark.asyncio
-    async def test_error_message_shows_available_channels(self):
-        """Test emit to non-existent channel works when others exist."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            # Register some channels
-            ctx._register_channel('channel1', asyncio.Queue())
-            ctx._register_channel('channel2', asyncio.Queue())
-
-            # Emit to non-existent channel should not raise (message dropped)
-            await ctx.emit('nonexistent', {'data': 42})
-            # No exception - emit to unconnected channels is allowed
-
-
-# Tests for get_channel_depths()
-class TestChannelMonitoring:
-    """Tests for ctx.get_channel_depths()."""
-
-    @pytest.mark.asyncio
-    async def test_get_channel_depths_empty(self):
-        """Test get_channel_depths() with empty channels."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            queue1 = asyncio.Queue(maxsize=10)
-            queue2 = asyncio.Queue(maxsize=20)
-            ctx._register_channel('ch1', queue1)
-            ctx._register_channel('ch2', queue2)
-
-            depths = ctx.get_channel_depths()
-
-            assert depths == {'ch1': 0, 'ch2': 0}
-
-    @pytest.mark.asyncio
-    async def test_get_channel_depths_with_messages(self):
-        """Test get_channel_depths() reports correct queue sizes."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            queue1 = asyncio.Queue(maxsize=10)
-            queue2 = asyncio.Queue(maxsize=20)
-            ctx._register_channel('data', queue1)
-            ctx._register_channel('results', queue2)
-
-            # Add messages to channels
-            await ctx.emit('data', 'msg1')
-            await ctx.emit('data', 'msg2')
-            await ctx.emit('data', 'msg3')
-            await ctx.emit('results', 'res1')
-
-            depths = ctx.get_channel_depths()
-
-            assert depths['data'] == 3
-            assert depths['results'] == 1
-
-    @pytest.mark.asyncio
-    async def test_get_channel_depths_updates_dynamically(self):
-        """Test get_channel_depths() reflects dynamic changes."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            queue = asyncio.Queue(maxsize=10)
-            ctx._register_channel('dynamic', queue)
-
-            # Initially empty
-            assert ctx.get_channel_depths()['dynamic'] == 0
-
-            # Add messages
-            await ctx.emit('dynamic', 'msg1')
-            await ctx.emit('dynamic', 'msg2')
-            assert ctx.get_channel_depths()['dynamic'] == 2
-
-            # Consume message
-            await ctx.receive('dynamic')
-            assert ctx.get_channel_depths()['dynamic'] == 1
-
-
-# Tests for set_result()
-class TestActorResults:
-    """Tests for ctx.set_result() for actor results."""
-
-    def test_set_result_basic(self):
-        """Test set_result() stores result in context."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            ctx.set_result('actor_123', {'count': 42, 'status': 'complete'})
-
-            result = ctx.get_result('actor_123')
-            assert result == {'count': 42, 'status': 'complete'}
-
-    def test_set_result_overwrites_existing(self):
-        """Test set_result() overwrites existing result."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            ctx.set_result('task_1', {'value': 10})
-            ctx.set_result('task_1', {'value': 20})
-
-            result = ctx.get_result('task_1')
-            assert result == {'value': 20}
-
-    def test_get_result_returns_none_for_nonexistent(self):
-        """Test get_result() returns None for non-existent key."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            result = ctx.get_result('nonexistent')
-            assert result is None
-
-    @pytest.mark.asyncio
-    async def test_set_result_used_by_actor(self):
-        """Test set_result() works in actor execution context."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            # Simulate actor calling set_result
-            actor_id = 'actor_456'
-            final_result = {
-                'items_processed': 100,
-                'errors': 0,
-                'success_rate': 1.0
-            }
-
-            ctx.set_result(actor_id, final_result)
-
-            # Verify result is stored
-            retrieved = ctx.get_result(actor_id)
-            assert retrieved == final_result
-
-
-# Tests for backward compatibility
-class TestBackwardCompatibility:
-    """Tests for backward compatibility with batch-only mode."""
-
-    def test_context_works_without_channels(self):
-        """Test RunContext works without any channels (batch mode)."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            # Should be able to use set_result and get_result
-            ctx.set_result('batch_task', {'output': 42})
-            result = ctx.get_result('batch_task')
-
-            assert result == {'output': 42}
-
-    def test_get_channel_depths_with_no_channels(self):
-        """Test get_channel_depths() returns empty dict when no channels."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            depths = ctx.get_channel_depths()
-
-            assert depths == {}
-
-    def test_batch_task_does_not_need_message_passing(self):
-        """Test batch tasks don't need emit/receive methods."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            # Batch task execution (no message passing)
-            # Just uses set_result
-            ctx.set_result('batch_1', {'data': [1, 2, 3]})
-            ctx.set_result('batch_2', {'processed': True})
-
-            # Verify both results stored
-            assert ctx.get_result('batch_1') == {'data': [1, 2, 3]}
-            assert ctx.get_result('batch_2') == {'processed': True}
-
-
-# Tests for channel registration
-class TestChannelRegistration:
-    """Tests for _register_channel() internal method."""
-
-    def test_register_channel_creates_entry(self):
-        """Test _register_channel() adds channel to internal map."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            queue = asyncio.Queue(maxsize=10)
-            ctx._register_channel('my_channel', queue)
-
-            # Channel should be accessible
-            assert 'my_channel' in ctx._channels
-            assert ctx._channels['my_channel'] is queue
-
-    def test_register_multiple_channels(self):
-        """Test registering multiple channels."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            queue1 = asyncio.Queue(maxsize=10)
-            queue2 = asyncio.Queue(maxsize=20)
-            queue3 = asyncio.Queue(maxsize=30)
-
-            ctx._register_channel('ch1', queue1)
-            ctx._register_channel('ch2', queue2)
-            ctx._register_channel('ch3', queue3)
-
-            assert len(ctx._channels) == 3
-            assert ctx._channels['ch1'] is queue1
-            assert ctx._channels['ch2'] is queue2
-            assert ctx._channels['ch3'] is queue3
-
-    def test_register_channel_overwrites_existing(self):
-        """Test re-registering channel overwrites previous."""
-        with TemporaryDirectory() as tmpdir:
-            run = MockRun(tmpdir)
-            ctx = RunContext(run)
-
-            queue1 = asyncio.Queue(maxsize=10)
-            queue2 = asyncio.Queue(maxsize=20)
-
-            ctx._register_channel('reused', queue1)
-            ctx._register_channel('reused', queue2)
-
-            assert ctx._channels['reused'] is queue2
diff --git a/ui/biome.json b/ui/biome.json
new file mode 100644
index 00000000..121a346a
--- /dev/null
+++ b/ui/biome.json
@@ -0,0 +1,19 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.4.11/schema.json",
+  "assist": { "actions": { "source": { "organizeImports": "on" } } },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100
+  },
+  "files": {
+    "includes": ["**/src/**/*.ts", "**/src/**/*.tsx", "!**/src/api/generated/**"]
+  }
+}
diff --git a/ui/mocks/README.md b/ui/mocks/README.md
index a510b519..4872105b 100644
--- a/ui/mocks/README.md
+++ b/ui/mocks/README.md
@@ -63,10 +63,10 @@ Run the dev server without `--mock` to connect to the real backend.
 
 ### Basic Test Setup
 
-Tests automatically use MSW via `ui/setupTests.ts`:
+Tests can use MSW through a shared setup file wired into `Rstest`:
 
 ```typescript
-import { beforeAll, afterEach, afterAll } from 'vitest';
+import { beforeAll, afterEach, afterAll } from '@rstest/core';
 import { server } from './mocks/node';
 import { resetDatabase } from './mocks/db';
 
@@ -153,8 +153,10 @@ The mock layer covers all API endpoints used by the frontend:
 - `POST /api/execute` - Trigger run execution
 - `GET /api/runs/:id/status` - Poll run status
 
-### Registry (Placeholder)
-- `GET /api/registry/tasks` - List available task types
+### Plugins / Registry
+- `GET /api/plugins` - List available UI plugins
+- `GET /api/tasks` - Task registry placeholder
+- `GET /api/tasks/:id` - Task detail placeholder
 
 ## Maintenance
 
diff --git a/ui/mocks/db/index.ts b/ui/mocks/db/index.ts
index bbdf7ade..11cf4386 100644
--- a/ui/mocks/db/index.ts
+++ b/ui/mocks/db/index.ts
@@ -6,6 +6,7 @@
  */
 
 import type {
+    ApiAgentSession,
     ApiProjectResponse,
     ApiExperimentResponse,
     ApiRunResponse,
@@ -33,6 +34,7 @@ interface MockDatabase {
     experiments: Map<string, ApiExperimentResponse>;
     runs: Map<string, ApiRunResponse>;
     assets: Map<string, ApiAssetResponse>;
+    agentSessions: Map<string, ApiAgentSession>;
     files: Map<string, FileNode>; // path -> node
     runLogs: Map<string, string[]>; // runId -> log lines
 }
@@ -59,6 +61,7 @@ function createEmptyDb(): MockDatabase {
         experiments: new Map(),
         runs: new Map(),
         assets: new Map(),
+        agentSessions: new Map(),
         files: new Map(),
         runLogs: new Map(),
     };
@@ -177,7 +180,13 @@ export function seed(): void {
                 gitCommit: "a1b2c3d",
                 serializedGraph: null,
             },
-            executorInfo: { backend: "local" },
+            executorInfo: {
+                backend: "molq",
+                scheduler: "slurm",
+                cluster_name: "default",
+                job_id: "molq-101",
+                scheduler_job_id: "421337",
+            },
             workingDir: "/tmp/molexp/run-001",
             logsDir: "/tmp/molexp/run-001/logs",
             assetRefs: {
@@ -542,6 +551,132 @@ outputs:
     };
 
     fileTree.forEach(addToFileMap);
+
+    // Agent sessions
+    const agentSessions: ApiAgentSession[] = [
+        {
+            sessionId: "sess-001",
+            status: "completed",
+            goalDescription: "Run the AlphaFold baseline experiment and summarise the results",
+            createdAt: isoAt(-180),
+            events: [
+                {
+                    type: "PlanCreatedEvent",
+                    ts: isoAt(-179),
+                    payload: {
+                        plan_steps: [
+                            "List existing experiments in protein-folding project",
+                            "Create a run for exp-001 with default parameters",
+                            "Wait for run completion",
+                            "Retrieve run summary and asset outputs",
+                        ],
+                    },
+                },
+                {
+                    type: "ToolCallEvent",
+                    ts: isoAt(-178),
+                    payload: { tool_name: "list_experiments", args: { project_id: "protein-folding" } },
+                },
+                {
+                    type: "ToolResultEvent",
+                    ts: isoAt(-178),
+                    payload: { tool_name: "list_experiments", result: ["exp-001 — AlphaFold Baseline", "exp-002 — Structure Sweep"] },
+                },
+                {
+                    type: "ToolCallEvent",
+                    ts: isoAt(-177),
+                    payload: { tool_name: "create_run", args: { project_id: "protein-folding", experiment_id: "exp-001", parameters: { batch_size: 32 } } },
+                },
+                {
+                    type: "ToolResultEvent",
+                    ts: isoAt(-177),
+                    payload: { tool_name: "create_run", result: { run_id: "run-001", status: "pending" } },
+                },
+                {
+                    type: "WorkflowStartedEvent",
+                    ts: isoAt(-176),
+                    payload: { run_id: "run-001", workflow_id: "exp-001" },
+                },
+                {
+                    type: "ObservationEvent",
+                    ts: isoAt(-120),
+                    payload: { content: "Run run-001 completed successfully. Output model saved to asset-003." },
+                },
+                {
+                    type: "SessionCompletedEvent",
+                    ts: isoAt(-119),
+                    payload: {
+                        summary: "AlphaFold baseline run completed. Model checkpoint saved as asset-003 (20 MB). Val loss: 0.032.",
+                        produced_runs: ["run-001"],
+                    },
+                },
+            ],
+        },
+        {
+            sessionId: "sess-002",
+            status: "completed",
+            goalDescription: "Screen catalyst library L1–L3 and report top candidates",
+            createdAt: isoAt(-90),
+            events: [
+                {
+                    type: "PlanCreatedEvent",
+                    ts: isoAt(-89),
+                    payload: {
+                        plan_steps: [
+                            "Locate catalyst-search project and exp-101",
+                            "Create run with ligand parameter sweep",
+                            "Analyse output candidates.csv",
+                        ],
+                    },
+                },
+                {
+                    type: "ToolCallEvent",
+                    ts: isoAt(-88),
+                    payload: { tool_name: "list_experiments", args: { project_id: "catalyst-search" } },
+                },
+                {
+                    type: "ToolResultEvent",
+                    ts: isoAt(-88),
+                    payload: { tool_name: "list_experiments", result: ["exp-101 — Catalyst Sweep"] },
+                },
+                {
+                    type: "WorkflowStartedEvent",
+                    ts: isoAt(-87),
+                    payload: { run_id: "run-101" },
+                },
+                {
+                    type: "SessionCompletedEvent",
+                    ts: isoAt(-50),
+                    payload: {
+                        summary: "Top 2 candidates identified: L2 (η = 0.87) and L1 (η = 0.81). Results written to candidates.csv.",
+                        produced_runs: ["run-101"],
+                    },
+                },
+            ],
+        },
+        {
+            sessionId: "sess-003",
+            status: "pending",
+            goalDescription: "Prepare a validated dataset from qm9.h5 and run a GNN baseline on it",
+            createdAt: isoAt(-5),
+            events: [
+                {
+                    type: "PlanCreatedEvent",
+                    ts: isoAt(-4),
+                    payload: {
+                        plan_steps: [
+                            "Validate qm9.h5 schema and integrity",
+                            "Create preprocessing experiment",
+                            "Run GNN baseline experiment",
+                            "Evaluate val_loss < 0.05",
+                        ],
+                    },
+                },
+            ],
+        },
+    ];
+
+    agentSessions.forEach((s) => db.agentSessions.set(s.sessionId, s));
 }
 
 /**
@@ -653,6 +788,23 @@ export function getAllAssets(): ApiAssetResponse[] {
     return Array.from(db.assets.values());
 }
 
+/**
+ * Get assets scoped to a project.
+ */
+export function getAssetsByProject(projectId: string): ApiAssetResponse[] {
+    if (projectId === "protein-folding") {
+        return Array.from(db.assets.values()).filter((asset) =>
+            asset.id === "asset-001" || asset.id === "asset-003"
+        );
+    }
+
+    if (projectId === "catalyst-search") {
+        return Array.from(db.assets.values()).filter((asset) => asset.id === "asset-002");
+    }
+
+    return [];
+}
+
 /**
  * Get asset by ID
  */
@@ -660,6 +812,13 @@ export function getAsset(id: string): ApiAssetResponse | undefined {
     return db.assets.get(id);
 }
 
+/**
+ * Add or update an asset.
+ */
+export function setAsset(asset: ApiAssetResponse): void {
+    db.assets.set(asset.id, asset);
+}
+
 /**
  * Get file tree (all root-level files)
  */
@@ -677,6 +836,31 @@ export function getFile(path: string): FileNode | undefined {
     return db.files.get(path);
 }
 
+/**
+ * Delete a file or folder by path.
+ */
+export function deleteFile(path: string): boolean {
+    const existing = db.files.get(path);
+    if (!existing) {
+        return false;
+    }
+
+    const prefix = path.endsWith("/") ? path : `${path}/`;
+    for (const candidatePath of Array.from(db.files.keys())) {
+        if (candidatePath === path || candidatePath.startsWith(prefix)) {
+            db.files.delete(candidatePath);
+        }
+    }
+
+    const parentPath = path.split("/").slice(0, -1).join("/") || "/";
+    const parent = db.files.get(parentPath);
+    if (parent?.children) {
+        parent.children = parent.children.filter((child) => child.path !== path);
+    }
+
+    return true;
+}
+
 /**
  * Write or update a file
  */
@@ -711,28 +895,6 @@ export function writeFile(path: string, content: string): void {
     }
 }
 
-/**
- * Delete a file
- */
-export function deleteFile(path: string): boolean {
-    const file = db.files.get(path);
-    if (!file) return false;
-
-    db.files.delete(path);
-
-    // Remove from parent's children
-    const parts = path.split("/").filter(Boolean);
-    if (parts.length > 1) {
-        const parentPath = "/" + parts.slice(0, -1).join("/");
-        const parent = db.files.get(parentPath);
-        if (parent && parent.children) {
-            parent.children = parent.children.filter((c) => c.path !== path);
-        }
-    }
-
-    return true;
-}
-
 /**
  * Create a directory
  */
@@ -792,3 +954,19 @@ export function addRunLog(runId: string, line: string): void {
     logs.push(line);
     db.runLogs.set(runId, logs);
 }
+
+// ============================================================================
+// Agent session accessors
+// ============================================================================
+
+export function getAllAgentSessions(): ApiAgentSession[] {
+    return Array.from(db.agentSessions.values());
+}
+
+export function getAgentSession(id: string): ApiAgentSession | undefined {
+    return db.agentSessions.get(id);
+}
+
+export function setAgentSession(session: ApiAgentSession): void {
+    db.agentSessions.set(session.sessionId, session);
+}
diff --git a/ui/mocks/handlers/agent.ts b/ui/mocks/handlers/agent.ts
new file mode 100644
index 00000000..1229afe8
--- /dev/null
+++ b/ui/mocks/handlers/agent.ts
@@ -0,0 +1,140 @@
+/**
+ * Mock handlers for Agent API endpoints
+ */
+
+import { http, HttpResponse } from "msw";
+import { getAllAgentSessions, getAgentSession, setAgentSession } from "../db";
+import type { ApiAgentSession } from "../../src/app/types";
+
+const API_BASE = "/api";
+
+export const agentHandlers = [
+    // GET /api/agent/sessions — list all sessions
+    http.get(`${API_BASE}/agent/sessions`, () => {
+        const sessions = getAllAgentSessions();
+        return HttpResponse.json({ sessions, total: sessions.length });
+    }),
+
+    // POST /api/agent/sessions — create a new session
+    http.post(`${API_BASE}/agent/sessions`, async ({ request }) => {
+        const body = (await request.json()) as {
+            description: string;
+            constraints?: Record<string, unknown>;
+            success_criteria?: string[];
+        };
+
+        const sessionId = `sess-${Date.now()}`;
+        const newSession: ApiAgentSession = {
+            sessionId,
+            status: "running",
+            goalDescription: body.description,
+            createdAt: new Date().toISOString(),
+            events: [
+                {
+                    type: "PlanCreatedEvent",
+                    ts: new Date().toISOString(),
+                    payload: {
+                        plan_steps: [
+                            "Analyse workspace and identify relevant experiments",
+                            "Execute requested workflow steps",
+                            "Summarise results and produced assets",
+                        ],
+                    },
+                },
+            ],
+        };
+
+        setAgentSession(newSession);
+
+        // Simulate session completing after a short delay (mock only)
+        setTimeout(() => {
+            const session = getAgentSession(sessionId);
+            if (!session) return;
+            const completed: ApiAgentSession = {
+                ...session,
+                status: "completed",
+                events: [
+                    ...session.events,
+                    {
+                        type: "ObservationEvent",
+                        ts: new Date().toISOString(),
+                        payload: { content: "All steps completed successfully." },
+                    },
+                    {
+                        type: "SessionCompletedEvent",
+                        ts: new Date().toISOString(),
+                        payload: {
+                            summary: `Goal completed: "${body.description}"`,
+                            produced_runs: [],
+                        },
+                    },
+                ],
+            };
+            setAgentSession(completed);
+        }, 3000);
+
+        return HttpResponse.json(newSession, { status: 201 });
+    }),
+
+    // GET /api/agent/sessions/:sessionId — get a single session
+    http.get(`${API_BASE}/agent/sessions/:sessionId`, ({ params }) => {
+        const session = getAgentSession(params.sessionId as string);
+        if (!session) {
+            return HttpResponse.json(
+                { detail: `Session ${params.sessionId} not found` },
+                { status: 404 },
+            );
+        }
+        return HttpResponse.json(session);
+    }),
+
+    // GET /api/agent/sessions/:sessionId/events — SSE stream of events
+    http.get(`${API_BASE}/agent/sessions/:sessionId/events`, ({ params }) => {
+        const session = getAgentSession(params.sessionId as string);
+
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                if (!session) {
+                    controller.enqueue(encoder.encode('data: {"type":"error","message":"Session not found"}\n\n'));
+                    controller.close();
+                    return;
+                }
+
+                // Send all existing events
+                for (const event of session.events) {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+                }
+
+                // Signal done or waiting
+                if (session.status !== "running") {
+                    controller.enqueue(encoder.encode('data: {"type":"done"}\n\n'));
+                } else {
+                    controller.enqueue(encoder.encode('data: {"type":"waiting"}\n\n'));
+                }
+
+                controller.close();
+            },
+        });
+
+        return new HttpResponse(stream, {
+            headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+            },
+        });
+    }),
+
+    // POST /api/agent/sessions/:sessionId/approve — respond to approval request
+    http.post(`${API_BASE}/agent/sessions/:sessionId/approve`, async ({ params, request }) => {
+        const session = getAgentSession(params.sessionId as string);
+        if (!session) {
+            return HttpResponse.json(
+                { detail: `Session ${params.sessionId} not found` },
+                { status: 404 },
+            );
+        }
+        const body = (await request.json()) as { request_id: string; approved: boolean };
+        return HttpResponse.json({ request_id: body.request_id, approved: body.approved, applied: true });
+    }),
+];
diff --git a/ui/mocks/handlers/assets.ts b/ui/mocks/handlers/assets.ts
index d50463a6..14c92325 100644
--- a/ui/mocks/handlers/assets.ts
+++ b/ui/mocks/handlers/assets.ts
@@ -3,7 +3,7 @@
  */
 
 import { http, HttpResponse } from "msw";
-import { getAllAssets } from "../db";
+import { getAllAssets, getAsset } from "../db";
 
 const API_BASE = "/api";
 
@@ -13,4 +13,27 @@ export const assetHandlers = [
         const assets = getAllAssets();
         return HttpResponse.json(assets);
     }),
+
+    // GET /api/assets/:assetId - Asset detail
+    http.get(`${API_BASE}/assets/:assetId`, ({ params }) => {
+        const asset = getAsset(params.assetId as string);
+        if (!asset) {
+            return HttpResponse.json({ detail: "Asset not found" }, { status: 404 });
+        }
+        return HttpResponse.json(asset);
+    }),
+
+    // GET /api/assets/:assetId/download - Binary asset download placeholder
+    http.get(`${API_BASE}/assets/:assetId/download`, ({ params }) => {
+        const asset = getAsset(params.assetId as string);
+        if (!asset) {
+            return HttpResponse.json({ detail: "Asset not found" }, { status: 404 });
+        }
+        return new HttpResponse(new Blob([]), {
+            headers: {
+                "Content-Type": asset.mimeType ?? "application/octet-stream",
+                "Content-Disposition": `attachment; filename=\"${asset.assetId}.${asset.format}\"`,
+            },
+        });
+    }),
 ];
diff --git a/ui/mocks/handlers/execution.ts b/ui/mocks/handlers/execution.ts
index af7eb16f..27447217 100644
--- a/ui/mocks/handlers/execution.ts
+++ b/ui/mocks/handlers/execution.ts
@@ -12,11 +12,7 @@ const API_BASE = "/api";
 
 export const executionHandlers = [
     // POST /api/execute - Trigger run execution (placeholder)
-    http.post(`${API_BASE}/execute`, async ({ request }) => {
-        const body = (await request.json()) as {
-            experimentId: string;
-            parameters?: Record<string, unknown>;
-        };
+    http.post(`${API_BASE}/execute`, async () => {
 
         // Mock run ID
         const runId = `run-${Date.now()}`;
diff --git a/ui/mocks/handlers/index.ts b/ui/mocks/handlers/index.ts
index 2152c859..3938d841 100644
--- a/ui/mocks/handlers/index.ts
+++ b/ui/mocks/handlers/index.ts
@@ -2,23 +2,25 @@
  * Central export for all MSW mock handlers
  */
 
-import { projectHandlers } from "./projects";
-import { experimentHandlers } from "./experiments";
-import { runHandlers } from "./runs";
+import { agentHandlers } from "./agent";
 import { assetHandlers } from "./assets";
-import { workspaceHandlers } from "./workspace";
 import { executionHandlers } from "./execution";
+import { experimentHandlers } from "./experiments";
+import { projectHandlers } from "./projects";
 import { registryHandlers } from "./registry";
+import { runHandlers } from "./runs";
+import { workspaceHandlers } from "./workspace";
 
 /**
  * All mock handlers combined
  */
 export const handlers = [
-    ...projectHandlers,
-    ...experimentHandlers,
-    ...runHandlers,
+    ...agentHandlers,
     ...assetHandlers,
-    ...workspaceHandlers,
     ...executionHandlers,
+    ...experimentHandlers,
+    ...projectHandlers,
     ...registryHandlers,
+    ...runHandlers,
+    ...workspaceHandlers,
 ];
diff --git a/ui/mocks/handlers/projects.ts b/ui/mocks/handlers/projects.ts
index ceb5073b..ff59b70d 100644
--- a/ui/mocks/handlers/projects.ts
+++ b/ui/mocks/handlers/projects.ts
@@ -3,7 +3,7 @@
  */
 
 import { http, HttpResponse } from "msw";
-import { getAllProjects, getProject, setProject, deleteProject, getAllAssets } from "../db";
+import { getAllProjects, getProject, setProject, deleteProject, getAssetsByProject } from "../db";
 import type { ApiProjectResponse } from "../../src/app/types";
 import type { ProjectCreateRequest } from "../../src/api/generated/models/ProjectCreateRequest";
 
@@ -32,8 +32,8 @@ export const projectHandlers = [
     }),
 
     // GET /api/projects/:id/assets - Get project assets
-    http.get(`${API_BASE}/projects/:id/assets`, () => {
-        const assets = getAllAssets();
+    http.get(`${API_BASE}/projects/:id/assets`, ({ params }) => {
+        const assets = getAssetsByProject(params.id as string);
         return HttpResponse.json(assets);
     }),
 
diff --git a/ui/mocks/handlers/registry.ts b/ui/mocks/handlers/registry.ts
index c3aae193..88b0dfac 100644
--- a/ui/mocks/handlers/registry.ts
+++ b/ui/mocks/handlers/registry.ts
@@ -1,8 +1,5 @@
 /**
  * Mock handlers for Registry API endpoints
- * 
- * Note: These endpoints were not found in the backend routes but are included
- * for potential future use based on the proposal requirements.
  */
 
 import { http, HttpResponse } from "msw";
@@ -10,38 +7,50 @@ import { http, HttpResponse } from "msw";
 const API_BASE = "/api";
 
 export const registryHandlers = [
-    // GET /api/registry/tasks - List available task types (placeholder)
-    http.get(`${API_BASE}/registry/tasks`, () => {
-        // Mock task registry
-        const tasks = [
-            {
-                id: "train",
-                label: "Train Model",
-                category: "ml",
-                description: "Train a machine learning model",
-                inputs: [
-                    { id: "dataset", label: "Dataset", type: "asset", required: true },
-                    { id: "config", label: "Config", type: "json", required: false },
-                ],
-                outputs: [
-                    { id: "model", label: "Model", type: "asset" },
-                ],
-            },
-            {
-                id: "evaluate",
-                label: "Evaluate Model",
-                category: "ml",
-                description: "Evaluate model performance",
-                inputs: [
-                    { id: "model", label: "Model", type: "asset", required: true },
-                    { id: "test_data", label: "Test Data", type: "asset", required: true },
-                ],
-                outputs: [
-                    { id: "metrics", label: "Metrics", type: "json" },
-                ],
-            },
-        ];
+  http.get(`${API_BASE}/plugins`, () => {
+    return HttpResponse.json({
+      plugins: [
+        {
+          id: "core",
+          title: "Core Workspace UI",
+          description: "Built-in Molexp workspace renderers and previews.",
+          uiModule: "core",
+          capabilities: ["workspace", "renderers", "file_previews"],
+          metadata: {},
+        },
+        {
+          id: "molq",
+          title: "Molq",
+          description: "Scheduler-aware run viewers and monitor surfaces for molq-backed runs.",
+          uiModule: "molq",
+          capabilities: ["submit", "monitor", "scheduler_inspector"],
+          metadata: {
+            schedulers: ["local", "slurm"],
+          },
+        },
+      ],
+      total: 2,
+    });
+  }),
 
-        return HttpResponse.json({ tasks });
-    }),
+  http.get(`${API_BASE}/tasks`, () => {
+    return HttpResponse.json(
+      {
+        error: "not_implemented",
+        message: "Task registry is being re-implemented in Phase 3.",
+        tasks: [],
+      },
+      { status: 501 },
+    );
+  }),
+
+  http.get(`${API_BASE}/tasks/:nodeId`, ({ params }) => {
+    return HttpResponse.json(
+      {
+        error: "not_implemented",
+        message: `Task registry is being re-implemented in Phase 3. Task '${params.nodeId}' not found.`,
+      },
+      { status: 501 },
+    );
+  }),
 ];
diff --git a/ui/mocks/handlers/runs.ts b/ui/mocks/handlers/runs.ts
index d6297975..4dbaed2d 100644
--- a/ui/mocks/handlers/runs.ts
+++ b/ui/mocks/handlers/runs.ts
@@ -3,7 +3,7 @@
  */
 
 import { http, HttpResponse } from "msw";
-import { getRunsByExperiment, setRun, deleteRun } from "../db";
+import { getRun, getRunsByExperiment, setRun, deleteRun } from "../db";
 import type { ApiRunResponse } from "../../src/app/types";
 import type { RunCreateRequest } from "../../src/api/generated/models/RunCreateRequest";
 
@@ -25,10 +25,11 @@ export const runHandlers = [
         async ({ request, params }) => {
             const { projectId, experimentId } = params;
             const body = (await request.json()) as RunCreateRequest;
+            const runId = body.git_commit ? `run-${body.git_commit.substring(0, 7)}` : `run-${Date.now()}`;
 
             const newRun: ApiRunResponse = {
-                id: body.git_commit ? `run-${body.git_commit.substring(0, 7)}` : `run-${Date.now()}`,
-                runId: body.git_commit ? `run-${body.git_commit.substring(0, 7)}` : `run-${Date.now()}`,
+                id: runId,
+                runId,
                 projectId: projectId as string,
                 experimentId: experimentId as string,
                 status: "pending",
@@ -51,6 +52,68 @@ export const runHandlers = [
             return HttpResponse.json(newRun, { status: 201 });
         }
     ),
+
+    // GET /api/projects/:projectId/experiments/:experimentId/runs/:runId - Run detail
+    http.get(
+        `${API_BASE}/projects/:projectId/experiments/:experimentId/runs/:runId`,
+        ({ params }) => {
+            const run = getRun(params.runId as string);
+            if (!run) {
+                return HttpResponse.json({ detail: "Run not found" }, { status: 404 });
+            }
+
+            return HttpResponse.json(run);
+        }
+    ),
+
+    // PATCH /api/projects/:projectId/experiments/:experimentId/runs/:runId/status - Update status
+    http.patch(
+        `${API_BASE}/projects/:projectId/experiments/:experimentId/runs/:runId/status`,
+        async ({ params, request }) => {
+            const run = getRun(params.runId as string);
+            if (!run) {
+                return HttpResponse.json({ detail: "Run not found" }, { status: 404 });
+            }
+
+            const body = (await request.json()) as { status?: string };
+            const nextStatus = body.status ?? run.status;
+            const updated: ApiRunResponse = {
+                ...run,
+                status: nextStatus,
+                finished:
+                    nextStatus === "succeeded" || nextStatus === "failed" || nextStatus === "cancelled"
+                        ? new Date().toISOString()
+                        : run.finished ?? null,
+            };
+
+            setRun(updated);
+
+            return HttpResponse.json({
+                id: updated.id,
+                status: updated.status,
+                finished: updated.finished,
+            });
+        }
+    ),
+
+    // POST /api/projects/:projectId/experiments/:experimentId/runs/:runId/start - Start run
+    http.post(
+        `${API_BASE}/projects/:projectId/experiments/:experimentId/runs/:runId/start`,
+        ({ params }) => {
+            const run = getRun(params.runId as string);
+            if (!run) {
+                return HttpResponse.json({ detail: "Run not found" }, { status: 404 });
+            }
+
+            const updated: ApiRunResponse = {
+                ...run,
+                status: "running",
+            };
+            setRun(updated);
+            return HttpResponse.json(updated);
+        }
+    ),
+
     // DELETE /api/projects/:projectId/experiments/:experimentId/runs/:runId
     http.delete(
         `${API_BASE}/projects/:projectId/experiments/:experimentId/runs/:runId`,
diff --git a/ui/mocks/handlers/workspace.ts b/ui/mocks/handlers/workspace.ts
index b1ae67fe..3f5b0d95 100644
--- a/ui/mocks/handlers/workspace.ts
+++ b/ui/mocks/handlers/workspace.ts
@@ -3,7 +3,15 @@
  */
 
 import { http, HttpResponse } from "msw";
-import { getFileTree, getFile, writeFile, createDirectory, getAllProjects, getAllAssets } from "../db";
+import {
+    createDirectory,
+    deleteFile,
+    getAllAssets,
+    getAllProjects,
+    getFile,
+    getFileTree,
+    writeFile,
+} from "../db";
 import type { FileNode } from "../db";
 
 const API_BASE = "/api";
@@ -77,6 +85,30 @@ export const workspaceHandlers = [
         });
     }),
 
+    // GET /api/files - Compatibility endpoint used by document resolvers
+    http.get(`${API_BASE}/files`, ({ request }) => {
+        const url = new URL(request.url);
+        const path = url.searchParams.get("path") || "";
+        const file = getFile(path);
+
+        if (!file || file.type !== "file") {
+            return HttpResponse.json({ message: "File not found" }, { status: 404 });
+        }
+
+        const content = file.content || "";
+        const trimmed = content.trim();
+
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+            try {
+                return HttpResponse.json(JSON.parse(content));
+            } catch {
+                return HttpResponse.json({ content });
+            }
+        }
+
+        return HttpResponse.json({ content });
+    }),
+
     // GET /api/workspace/file/blob - Read file content (binary)
     http.get(`${API_BASE}/workspace/file/blob`, ({ request }) => {
         const url = new URL(request.url);
@@ -90,11 +122,13 @@ export const workspaceHandlers = [
             );
         }
 
-        // For mock purposes, return empty blob
-        // In a real implementation, this would return actual binary data
-        return new HttpResponse(new Blob([]), {
+        const lowerPath = path.toLowerCase();
+        const isImage =
+            lowerPath.endsWith(".png") || lowerPath.endsWith(".jpg") || lowerPath.endsWith(".jpeg");
+
+        return new HttpResponse(new Blob([file.content || ""]), {
             headers: {
-                "Content-Type": "application/octet-stream",
+                "Content-Type": isImage ? "image/png" : "application/octet-stream",
             },
         });
     }),
@@ -139,4 +173,17 @@ export const workspaceHandlers = [
             path: body.path,
         });
     }),
+
+    // DELETE /api/workspace/files - Optional file deletion used by explorer actions
+    http.delete(`${API_BASE}/workspace/files`, ({ request }) => {
+        const url = new URL(request.url);
+        const path = url.searchParams.get("path") || "";
+        const deleted = deleteFile(path);
+
+        if (!deleted) {
+            return HttpResponse.json({ message: "File not found" }, { status: 404 });
+        }
+
+        return HttpResponse.json({ path });
+    }),
 ];
diff --git a/ui/package-lock.json b/ui/package-lock.json
index b5097e23..f316c6be 100644
--- a/ui/package-lock.json
+++ b/ui/package-lock.json
@@ -44,8 +44,10 @@
         "zustand": "^5.0.8"
       },
       "devDependencies": {
+        "@biomejs/biome": "^2.4.11",
         "@rsbuild/core": "^1.6.7",
         "@rsbuild/plugin-react": "^1.4.2",
+        "@rstest/core": "^0.7.0",
         "@tailwindcss/postcss": "^4.1.17",
         "@types/react": "^19.2.6",
         "@types/react-dom": "^19.2.3",
@@ -88,477 +90,96 @@
         "@types/json-schema": "^7.0.15"
       }
     },
-    "node_modules/@emnapi/core": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.7.1.tgz",
-      "integrity": "sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg==",
+    "node_modules/@biomejs/biome": {
+      "version": "2.4.11",
+      "resolved": "https://registry.npmjs.org/@biomejs/biome/-/biome-2.4.11.tgz",
+      "integrity": "sha512-nWxHX8tf3Opb/qRgZpBbsTOqOodkbrkJ7S+JxJAruxOReaDPPmPuLBAGQ8vigyUgo0QBB+oQltNEAvalLcjggA==",
       "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@emnapi/wasi-threads": "1.1.0",
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@emnapi/runtime": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.7.1.tgz",
-      "integrity": "sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@emnapi/wasi-threads": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz",
-      "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz",
-      "integrity": "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.2.tgz",
-      "integrity": "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz",
-      "integrity": "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.2.tgz",
-      "integrity": "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
+      "license": "MIT OR Apache-2.0",
+      "bin": {
+        "biome": "bin/biome"
+      },
       "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz",
-      "integrity": "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==",
+        "node": ">=14.21.3"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/biome"
+      },
+      "optionalDependencies": {
+        "@biomejs/cli-darwin-arm64": "2.4.11",
+        "@biomejs/cli-darwin-x64": "2.4.11",
+        "@biomejs/cli-linux-arm64": "2.4.11",
+        "@biomejs/cli-linux-arm64-musl": "2.4.11",
+        "@biomejs/cli-linux-x64": "2.4.11",
+        "@biomejs/cli-linux-x64-musl": "2.4.11",
+        "@biomejs/cli-win32-arm64": "2.4.11",
+        "@biomejs/cli-win32-x64": "2.4.11"
+      }
+    },
+    "node_modules/@biomejs/cli-darwin-arm64": {
+      "version": "2.4.11",
+      "resolved": "https://registry.npmjs.org/@biomejs/cli-darwin-arm64/-/cli-darwin-arm64-2.4.11.tgz",
+      "integrity": "sha512-wOt+ed+L2dgZanWyL6i29qlXMc088N11optzpo10peayObBaAshbTcxKUchzEMp9QSY8rh5h6VfAFE3WTS1rqg==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "license": "MIT",
+      "license": "MIT OR Apache-2.0",
       "optional": true,
       "os": [
         "darwin"
       ],
       "engines": {
-        "node": ">=18"
+        "node": ">=14.21.3"
       }
     },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz",
-      "integrity": "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz",
-      "integrity": "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz",
-      "integrity": "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz",
-      "integrity": "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz",
-      "integrity": "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz",
-      "integrity": "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz",
-      "integrity": "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz",
-      "integrity": "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz",
-      "integrity": "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz",
-      "integrity": "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz",
-      "integrity": "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz",
-      "integrity": "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz",
-      "integrity": "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz",
-      "integrity": "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz",
-      "integrity": "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz",
-      "integrity": "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz",
-      "integrity": "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz",
-      "integrity": "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@emnapi/core": {
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.7.1.tgz",
+      "integrity": "sha512-o1uhUASyo921r2XtHYOHy7gdkGLge8ghBEQHMWmyJFoXlpU58kIrhhN3w26lpQb6dspetweapMn2CSNwQ8I4wg==",
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz",
-      "integrity": "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==",
-      "cpu": [
-        "arm64"
-      ],
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.1.0",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.7.1.tgz",
+      "integrity": "sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==",
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
+      "dependencies": {
+        "tslib": "^2.4.0"
       }
     },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz",
-      "integrity": "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==",
-      "cpu": [
-        "ia32"
-      ],
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz",
+      "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==",
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
+      "dependencies": {
+        "tslib": "^2.4.0"
       }
     },
-    "node_modules/@esbuild/win32-x64": {
+    "node_modules/@esbuild/darwin-arm64": {
       "version": "0.27.2",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz",
-      "integrity": "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz",
+      "integrity": "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==",
       "cpu": [
-        "x64"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "win32"
+        "darwin"
       ],
       "engines": {
         "node": ">=18"
@@ -741,62 +362,62 @@
       }
     },
     "node_modules/@module-federation/error-codes": {
-      "version": "0.21.4",
-      "resolved": "https://registry.npmjs.org/@module-federation/error-codes/-/error-codes-0.21.4.tgz",
-      "integrity": "sha512-ClpL5MereWNXh+EgDjz7w4RrC1JlisQTvXDa1gLxpviHafzNDfdViVmuhi9xXVuj+EYo8KU70Y999KHhk9424Q==",
+      "version": "0.22.0",
+      "resolved": "https://registry.npmjs.org/@module-federation/error-codes/-/error-codes-0.22.0.tgz",
+      "integrity": "sha512-xF9SjnEy7vTdx+xekjPCV5cIHOGCkdn3pIxo9vU7gEZMIw0SvAEdsy6Uh17xaCpm8V0FWvR0SZoK9Ik6jGOaug==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@module-federation/runtime": {
-      "version": "0.21.4",
-      "resolved": "https://registry.npmjs.org/@module-federation/runtime/-/runtime-0.21.4.tgz",
-      "integrity": "sha512-wgvGqryurVEvkicufJmTG0ZehynCeNLklv8kIk5BLIsWYSddZAE+xe4xov1kgH5fIJQAoQNkRauFFjVNlHoAkA==",
+      "version": "0.22.0",
+      "resolved": "https://registry.npmjs.org/@module-federation/runtime/-/runtime-0.22.0.tgz",
+      "integrity": "sha512-38g5iPju2tPC3KHMPxRKmy4k4onNp6ypFPS1eKGsNLUkXgHsPMBFqAjDw96iEcjri91BrahG4XcdyKi97xZzlA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@module-federation/error-codes": "0.21.4",
-        "@module-federation/runtime-core": "0.21.4",
-        "@module-federation/sdk": "0.21.4"
+        "@module-federation/error-codes": "0.22.0",
+        "@module-federation/runtime-core": "0.22.0",
+        "@module-federation/sdk": "0.22.0"
       }
     },
     "node_modules/@module-federation/runtime-core": {
-      "version": "0.21.4",
-      "resolved": "https://registry.npmjs.org/@module-federation/runtime-core/-/runtime-core-0.21.4.tgz",
-      "integrity": "sha512-SGpmoOLGNxZofpTOk6Lxb2ewaoz5wMi93AFYuuJB04HTVcngEK+baNeUZ2D/xewrqNIJoMY6f5maUjVfIIBPUA==",
+      "version": "0.22.0",
+      "resolved": "https://registry.npmjs.org/@module-federation/runtime-core/-/runtime-core-0.22.0.tgz",
+      "integrity": "sha512-GR1TcD6/s7zqItfhC87zAp30PqzvceoeDGYTgF3Vx2TXvsfDrhP6Qw9T4vudDQL3uJRne6t7CzdT29YyVxlgIA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@module-federation/error-codes": "0.21.4",
-        "@module-federation/sdk": "0.21.4"
+        "@module-federation/error-codes": "0.22.0",
+        "@module-federation/sdk": "0.22.0"
       }
     },
     "node_modules/@module-federation/runtime-tools": {
-      "version": "0.21.4",
-      "resolved": "https://registry.npmjs.org/@module-federation/runtime-tools/-/runtime-tools-0.21.4.tgz",
-      "integrity": "sha512-RzFKaL0DIjSmkn76KZRfzfB6dD07cvID84950jlNQgdyoQFUGkqD80L6rIpVCJTY/R7LzR3aQjHnoqmq4JPo3w==",
+      "version": "0.22.0",
+      "resolved": "https://registry.npmjs.org/@module-federation/runtime-tools/-/runtime-tools-0.22.0.tgz",
+      "integrity": "sha512-4ScUJ/aUfEernb+4PbLdhM/c60VHl698Gn1gY21m9vyC1Ucn69fPCA1y2EwcCB7IItseRMoNhdcWQnzt/OPCNA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@module-federation/runtime": "0.21.4",
-        "@module-federation/webpack-bundler-runtime": "0.21.4"
+        "@module-federation/runtime": "0.22.0",
+        "@module-federation/webpack-bundler-runtime": "0.22.0"
       }
     },
     "node_modules/@module-federation/sdk": {
-      "version": "0.21.4",
-      "resolved": "https://registry.npmjs.org/@module-federation/sdk/-/sdk-0.21.4.tgz",
-      "integrity": "sha512-tzvhOh/oAfX++6zCDDxuvioHY4Jurf8vcfoCbKFxusjmyKr32GPbwFDazUP+OPhYCc3dvaa9oWU6X/qpUBLfJw==",
+      "version": "0.22.0",
+      "resolved": "https://registry.npmjs.org/@module-federation/sdk/-/sdk-0.22.0.tgz",
+      "integrity": "sha512-x4aFNBKn2KVQRuNVC5A7SnrSCSqyfIWmm1DvubjbO9iKFe7ith5niw8dqSFBekYBg2Fwy+eMg4sEFNVvCAdo6g==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@module-federation/webpack-bundler-runtime": {
-      "version": "0.21.4",
-      "resolved": "https://registry.npmjs.org/@module-federation/webpack-bundler-runtime/-/webpack-bundler-runtime-0.21.4.tgz",
-      "integrity": "sha512-dusmR3uPnQh9u9ChQo3M+GLOuGFthfvnh7WitF/a1eoeTfRmXqnMFsXtZCUK+f/uXf+64874Zj/bhAgbBcVHZA==",
+      "version": "0.22.0",
+      "resolved": "https://registry.npmjs.org/@module-federation/webpack-bundler-runtime/-/webpack-bundler-runtime-0.22.0.tgz",
+      "integrity": "sha512-aM8gCqXu+/4wBmJtVeMeeMN5guw3chf+2i6HajKtQv7SJfxV/f4IyNQJUeUQu9HfiAZHjqtMV5Lvq/Lvh8LdyA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@module-federation/runtime": "0.21.4",
-        "@module-federation/sdk": "0.21.4"
+        "@module-federation/runtime": "0.22.0",
+        "@module-federation/sdk": "0.22.0"
       }
     },
     "node_modules/@monaco-editor/loader": {
@@ -2613,15 +2234,15 @@
       "license": "MIT"
     },
     "node_modules/@rsbuild/core": {
-      "version": "1.6.9",
-      "resolved": "https://registry.npmjs.org/@rsbuild/core/-/core-1.6.9.tgz",
-      "integrity": "sha512-wf41bbFIzqQsGkrDal2eVC4cxN6II1k4bUo1g7OFuvWeEOJzjoeK4R5xxKM9g5hRjbGAJs6OiQaGpASvUnDrsw==",
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/@rsbuild/core/-/core-1.7.1.tgz",
+      "integrity": "sha512-ULIE/Qh+Ne80Pm/aUPbRHUvwvIzpap07jYNFB47azI8w5Q3sDEC4Gn574jsluT/42iNDsZTFADRBog9FEvtN9Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@rspack/core": "1.6.5",
+        "@rspack/core": "1.7.0",
         "@rspack/lite-tapable": "~1.1.0",
-        "@swc/helpers": "^0.5.17",
+        "@swc/helpers": "^0.5.18",
         "core-js": "~3.47.0",
         "jiti": "^2.6.1"
       },
@@ -2647,28 +2268,28 @@
       }
     },
     "node_modules/@rspack/binding": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding/-/binding-1.6.5.tgz",
-      "integrity": "sha512-FzYsr5vdjaVQIlDTxZFlISOQGxl/4grpF2BeiNy60Fpw9eeADeXk55DVacbXPqpiz7Doj6cyhEyMszQOvihrqQ==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/@rspack/binding/-/binding-1.7.0.tgz",
+      "integrity": "sha512-xO+pZKG2dvU9CuRTTi+DcCc4p+CZhBJlvuYikBja/0a62cTntQV2PWV+/xU1a6Vbo89yNz158LR05nvjtKVwTw==",
       "dev": true,
       "license": "MIT",
       "optionalDependencies": {
-        "@rspack/binding-darwin-arm64": "1.6.5",
-        "@rspack/binding-darwin-x64": "1.6.5",
-        "@rspack/binding-linux-arm64-gnu": "1.6.5",
-        "@rspack/binding-linux-arm64-musl": "1.6.5",
-        "@rspack/binding-linux-x64-gnu": "1.6.5",
-        "@rspack/binding-linux-x64-musl": "1.6.5",
-        "@rspack/binding-wasm32-wasi": "1.6.5",
-        "@rspack/binding-win32-arm64-msvc": "1.6.5",
-        "@rspack/binding-win32-ia32-msvc": "1.6.5",
-        "@rspack/binding-win32-x64-msvc": "1.6.5"
+        "@rspack/binding-darwin-arm64": "1.7.0",
+        "@rspack/binding-darwin-x64": "1.7.0",
+        "@rspack/binding-linux-arm64-gnu": "1.7.0",
+        "@rspack/binding-linux-arm64-musl": "1.7.0",
+        "@rspack/binding-linux-x64-gnu": "1.7.0",
+        "@rspack/binding-linux-x64-musl": "1.7.0",
+        "@rspack/binding-wasm32-wasi": "1.7.0",
+        "@rspack/binding-win32-arm64-msvc": "1.7.0",
+        "@rspack/binding-win32-ia32-msvc": "1.7.0",
+        "@rspack/binding-win32-x64-msvc": "1.7.0"
       }
     },
     "node_modules/@rspack/binding-darwin-arm64": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-darwin-arm64/-/binding-darwin-arm64-1.6.5.tgz",
-      "integrity": "sha512-DaAJTlaenqZIqFqIYcitn0SzjJ7WpC9234JpiSDZdRyXii9qJJiToVwxSPY/CmkrP0201+aC4pzN4tI9T0Ummw==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-darwin-arm64/-/binding-darwin-arm64-1.7.0.tgz",
+      "integrity": "sha512-HMYrhvVh3sMRBXl6cSI2JqsvlHJKQ42qX+Sw4qbj7LeZBN6Gv4GjfL3cXRLUTdO37FOC0uLEUYgxVXetx/Y4sA==",
       "cpu": [
         "arm64"
       ],
@@ -2679,141 +2300,15 @@
         "darwin"
       ]
     },
-    "node_modules/@rspack/binding-darwin-x64": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-darwin-x64/-/binding-darwin-x64-1.6.5.tgz",
-      "integrity": "sha512-fPVfp7W/GMbHayb5hbefiMI30JxlsqPexOItHGtufHmTCrNne1aHmApspyUZIUUxG36oDRHuGPnfh+IQbHR6+g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rspack/binding-linux-arm64-gnu": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.6.5.tgz",
-      "integrity": "sha512-K68YDoV2e4s+nlrKZxgF0HehiiRwOAGgZFUwJNRMZ7MUrTGMNlPTJlM+bNdaCjDb6GFxBVFcNwIa1sU+0tF1zg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rspack/binding-linux-arm64-musl": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.6.5.tgz",
-      "integrity": "sha512-JPtxFBOq7RRmBIwpdGIStf8iyCILehDsjQtEB0Kkhtm7TsAkVGwtC41GLcNuPxcQBKqNDmD8cy3yLYhXadH2CQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rspack/binding-linux-x64-gnu": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.6.5.tgz",
-      "integrity": "sha512-oh4ZNo2HtizZ/E6UK3BEONu20h8VVBw9GAXuWmo1u22cJSihzg+WfRNCMjRDil82LqSsyAgBwnU+dEjEYGKyAA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rspack/binding-linux-x64-musl": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-x64-musl/-/binding-linux-x64-musl-1.6.5.tgz",
-      "integrity": "sha512-8Xebp5bvPJqjifpkFEAX5nUvoU2JvbMU3gwAkEovRRuvooCXnVT2tqkUBjkR3AhivAGgAxAr9hRzUUz/6QWt3Q==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rspack/binding-wasm32-wasi": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-wasm32-wasi/-/binding-wasm32-wasi-1.6.5.tgz",
-      "integrity": "sha512-oINZNqzTxM+9dSUOjAORodHXYoJYzXvpaHI2U6ecEmoWaBCs+x3V3Po8DhpNFBwotB+jGlcoVhEHjpg5uaO6pw==",
-      "cpu": [
-        "wasm32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@napi-rs/wasm-runtime": "1.0.7"
-      }
-    },
-    "node_modules/@rspack/binding-win32-arm64-msvc": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.6.5.tgz",
-      "integrity": "sha512-UUmep2ayuZxWPdrzkrzAFxVgYUWTB82pa9bkAGyeDO9SNkz8vTpdtbDaTvAzjFb8Pn+ErktDEDBKT57FLjxwxQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rspack/binding-win32-ia32-msvc": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-1.6.5.tgz",
-      "integrity": "sha512-7nx+mMimpmCMstcW7nsyToXy5TK7N+YGPu2W/oioX7qv9ZCuJGTddjzLS84wN8DVrNIirg4mcxpBsmOQMZeHQA==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rspack/binding-win32-x64-msvc": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.6.5.tgz",
-      "integrity": "sha512-pzO7rYFu6f6stgSccolZHiXGTTwKrIGHHNV1ALY1xPRmQEdbHcbMwadeaG99JL2lRLve9iNI+Z9Pr3oDVRN46g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
     "node_modules/@rspack/core": {
-      "version": "1.6.5",
-      "resolved": "https://registry.npmjs.org/@rspack/core/-/core-1.6.5.tgz",
-      "integrity": "sha512-AqaOMA6MTNhqMYYwrhvPA+2uS662SkAi8Rb7B/IFOzh/Z5ooyczL4lUX+qyhAO3ymn50iwM4jikQCf9XfBiaQA==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/@rspack/core/-/core-1.7.0.tgz",
+      "integrity": "sha512-uDxPQsPh/+2DnOISuKnUiXZ9M0y2G1BOsI0IesxPJGp42ME2QW7axbJfUqD3bwp4bi3RN2zqh56NgxU/XETQvA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@module-federation/runtime-tools": "0.21.4",
-        "@rspack/binding": "1.6.5",
+        "@module-federation/runtime-tools": "0.22.0",
+        "@rspack/binding": "1.7.0",
         "@rspack/lite-tapable": "1.1.0"
       },
       "engines": {
@@ -2855,268 +2350,98 @@
         }
       }
     },
-    "node_modules/@swc/helpers": {
-      "version": "0.5.17",
-      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.17.tgz",
-      "integrity": "sha512-5IKx/Y13RsYd+sauPb2x+U/xZikHjolzfuDgTAl/Tdf3Q8rslRvC19NKDLgAJQ6wsqADk10ntlv08nPFw/gO/A==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.8.0"
-      }
-    },
-    "node_modules/@tailwindcss/node": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.1.17.tgz",
-      "integrity": "sha512-csIkHIgLb3JisEFQ0vxr2Y57GUNYh447C8xzwj89U/8fdW8LhProdxvnVH6U8M2Y73QKiTIH+LWbK3V2BBZsAg==",
+    "node_modules/@rstest/core": {
+      "version": "0.7.9",
+      "resolved": "https://registry.npmjs.org/@rstest/core/-/core-0.7.9.tgz",
+      "integrity": "sha512-RHNPS1MDUxtf+1Z0YZi+vIQ13SdvCbcbpzDA7XHcPziTRy2mAPg8nfcms+XzbIp95KXH75ucAhgAKNFO0QgARA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jridgewell/remapping": "^2.3.4",
-        "enhanced-resolve": "^5.18.3",
-        "jiti": "^2.6.1",
-        "lightningcss": "1.30.2",
-        "magic-string": "^0.30.21",
-        "source-map-js": "^1.2.1",
-        "tailwindcss": "4.1.17"
-      }
-    },
-    "node_modules/@tailwindcss/oxide": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.1.17.tgz",
-      "integrity": "sha512-F0F7d01fmkQhsTjXezGBLdrl1KresJTcI3DB8EkScCldyKp3Msz4hub4uyYaVnk88BAS1g5DQjjF6F5qczheLA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10"
+        "@rsbuild/core": "1.7.1",
+        "@types/chai": "^5.2.3",
+        "tinypool": "^1.1.1"
+      },
+      "bin": {
+        "rstest": "bin/rstest.js"
       },
-      "optionalDependencies": {
-        "@tailwindcss/oxide-android-arm64": "4.1.17",
-        "@tailwindcss/oxide-darwin-arm64": "4.1.17",
-        "@tailwindcss/oxide-darwin-x64": "4.1.17",
-        "@tailwindcss/oxide-freebsd-x64": "4.1.17",
-        "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.17",
-        "@tailwindcss/oxide-linux-arm64-gnu": "4.1.17",
-        "@tailwindcss/oxide-linux-arm64-musl": "4.1.17",
-        "@tailwindcss/oxide-linux-x64-gnu": "4.1.17",
-        "@tailwindcss/oxide-linux-x64-musl": "4.1.17",
-        "@tailwindcss/oxide-wasm32-wasi": "4.1.17",
-        "@tailwindcss/oxide-win32-arm64-msvc": "4.1.17",
-        "@tailwindcss/oxide-win32-x64-msvc": "4.1.17"
-      }
-    },
-    "node_modules/@tailwindcss/oxide-android-arm64": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.1.17.tgz",
-      "integrity": "sha512-BMqpkJHgOZ5z78qqiGE6ZIRExyaHyuxjgrJ6eBO5+hfrfGkuya0lYfw8fRHG77gdTjWkNWEEm+qeG2cDMxArLQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@tailwindcss/oxide-darwin-arm64": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.1.17.tgz",
-      "integrity": "sha512-EquyumkQweUBNk1zGEU/wfZo2qkp/nQKRZM8bUYO0J+Lums5+wl2CcG1f9BgAjn/u9pJzdYddHWBiFXJTcxmOg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@tailwindcss/oxide-darwin-x64": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.1.17.tgz",
-      "integrity": "sha512-gdhEPLzke2Pog8s12oADwYu0IAw04Y2tlmgVzIN0+046ytcgx8uZmCzEg4VcQh+AHKiS7xaL8kGo/QTiNEGRog==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@tailwindcss/oxide-freebsd-x64": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.1.17.tgz",
-      "integrity": "sha512-hxGS81KskMxML9DXsaXT1H0DyA+ZBIbyG/sSAjWNe2EDl7TkPOBI42GBV3u38itzGUOmFfCzk1iAjDXds8Oh0g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.1.17.tgz",
-      "integrity": "sha512-k7jWk5E3ldAdw0cNglhjSgv501u7yrMf8oeZ0cElhxU6Y2o7f8yqelOp3fhf7evjIS6ujTI3U8pKUXV2I4iXHQ==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@tailwindcss/oxide-linux-arm64-gnu": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.1.17.tgz",
-      "integrity": "sha512-HVDOm/mxK6+TbARwdW17WrgDYEGzmoYayrCgmLEw7FxTPLcp/glBisuyWkFz/jb7ZfiAXAXUACfyItn+nTgsdQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@tailwindcss/oxide-linux-arm64-musl": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.1.17.tgz",
-      "integrity": "sha512-HvZLfGr42i5anKtIeQzxdkw/wPqIbpeZqe7vd3V9vI3RQxe3xU1fLjss0TjyhxWcBaipk7NYwSrwTwK1hJARMg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@tailwindcss/oxide-linux-x64-gnu": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.1.17.tgz",
-      "integrity": "sha512-M3XZuORCGB7VPOEDH+nzpJ21XPvK5PyjlkSFkFziNHGLc5d6g3di2McAAblmaSUNl8IOmzYwLx9NsE7bplNkwQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
       "engines": {
-        "node": ">= 10"
+        "node": ">=18.12.0"
+      },
+      "peerDependencies": {
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@tailwindcss/oxide-linux-x64-musl": {
-      "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.1.17.tgz",
-      "integrity": "sha512-k7f+pf9eXLEey4pBlw+8dgfJHY4PZ5qOUFDyNf7SI6lHjQ9Zt7+NcscjpwdCEbYi6FI5c2KDTDWyf2iHcCSyyQ==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@swc/helpers": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.21.tgz",
+      "integrity": "sha512-jI/VAmtdjB/RnI8GTnokyX7Ug8c+g+ffD6QRLa6XQewtnGyukKkKSk3wLTM3b5cjt1jNh9x0jfVlagdN2gDKQg==",
       "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.8.0"
       }
     },
-    "node_modules/@tailwindcss/oxide-wasm32-wasi": {
+    "node_modules/@tailwindcss/node": {
       "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.1.17.tgz",
-      "integrity": "sha512-cEytGqSSoy7zK4JRWiTCx43FsKP/zGr0CsuMawhH67ONlH+T79VteQeJQRO/X7L0juEUA8ZyuYikcRBf0vsxhg==",
-      "bundleDependencies": [
-        "@napi-rs/wasm-runtime",
-        "@emnapi/core",
-        "@emnapi/runtime",
-        "@tybys/wasm-util",
-        "@emnapi/wasi-threads",
-        "tslib"
-      ],
-      "cpu": [
-        "wasm32"
-      ],
+      "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.1.17.tgz",
+      "integrity": "sha512-csIkHIgLb3JisEFQ0vxr2Y57GUNYh447C8xzwj89U/8fdW8LhProdxvnVH6U8M2Y73QKiTIH+LWbK3V2BBZsAg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
       "dependencies": {
-        "@emnapi/core": "^1.6.0",
-        "@emnapi/runtime": "^1.6.0",
-        "@emnapi/wasi-threads": "^1.1.0",
-        "@napi-rs/wasm-runtime": "^1.0.7",
-        "@tybys/wasm-util": "^0.10.1",
-        "tslib": "^2.4.0"
-      },
-      "engines": {
-        "node": ">=14.0.0"
+        "@jridgewell/remapping": "^2.3.4",
+        "enhanced-resolve": "^5.18.3",
+        "jiti": "^2.6.1",
+        "lightningcss": "1.30.2",
+        "magic-string": "^0.30.21",
+        "source-map-js": "^1.2.1",
+        "tailwindcss": "4.1.17"
       }
     },
-    "node_modules/@tailwindcss/oxide-win32-arm64-msvc": {
+    "node_modules/@tailwindcss/oxide": {
       "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.1.17.tgz",
-      "integrity": "sha512-JU5AHr7gKbZlOGvMdb4722/0aYbU+tN6lv1kONx0JK2cGsh7g148zVWLM0IKR3NeKLv+L90chBVYcJ8uJWbC9A==",
-      "cpu": [
-        "arm64"
-      ],
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.1.17.tgz",
+      "integrity": "sha512-F0F7d01fmkQhsTjXezGBLdrl1KresJTcI3DB8EkScCldyKp3Msz4hub4uyYaVnk88BAS1g5DQjjF6F5qczheLA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
       "engines": {
         "node": ">= 10"
+      },
+      "optionalDependencies": {
+        "@tailwindcss/oxide-android-arm64": "4.1.17",
+        "@tailwindcss/oxide-darwin-arm64": "4.1.17",
+        "@tailwindcss/oxide-darwin-x64": "4.1.17",
+        "@tailwindcss/oxide-freebsd-x64": "4.1.17",
+        "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.17",
+        "@tailwindcss/oxide-linux-arm64-gnu": "4.1.17",
+        "@tailwindcss/oxide-linux-arm64-musl": "4.1.17",
+        "@tailwindcss/oxide-linux-x64-gnu": "4.1.17",
+        "@tailwindcss/oxide-linux-x64-musl": "4.1.17",
+        "@tailwindcss/oxide-wasm32-wasi": "4.1.17",
+        "@tailwindcss/oxide-win32-arm64-msvc": "4.1.17",
+        "@tailwindcss/oxide-win32-x64-msvc": "4.1.17"
       }
     },
-    "node_modules/@tailwindcss/oxide-win32-x64-msvc": {
+    "node_modules/@tailwindcss/oxide-darwin-arm64": {
       "version": "4.1.17",
-      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.1.17.tgz",
-      "integrity": "sha512-SKWM4waLuqx0IH+FMDUw6R66Hu4OuTALFgnleKbqhgGU30DY20NORZMZUKgLRjQXNN2TLzKvh48QXTig4h4bGw==",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.1.17.tgz",
+      "integrity": "sha512-EquyumkQweUBNk1zGEU/wfZo2qkp/nQKRZM8bUYO0J+Lums5+wl2CcG1f9BgAjn/u9pJzdYddHWBiFXJTcxmOg==",
       "cpu": [
-        "x64"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "win32"
+        "darwin"
       ],
       "engines": {
         "node": ">= 10"
@@ -3147,6 +2472,17 @@
         "tslib": "^2.4.0"
       }
     },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
     "node_modules/@types/d3-color": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz",
@@ -3205,6 +2541,13 @@
         "@types/ms": "*"
       }
     },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -3424,6 +2767,16 @@
         "node": ">=10"
       }
     },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/asynckit": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
@@ -4645,27 +3998,6 @@
         "lightningcss-win32-x64-msvc": "1.30.2"
       }
     },
-    "node_modules/lightningcss-android-arm64": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.30.2.tgz",
-      "integrity": "sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
     "node_modules/lightningcss-darwin-arm64": {
       "version": "1.30.2",
       "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.30.2.tgz",
@@ -4687,195 +4019,6 @@
         "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/lightningcss-darwin-x64": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.30.2.tgz",
-      "integrity": "sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-freebsd-x64": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.30.2.tgz",
-      "integrity": "sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-arm-gnueabihf": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.30.2.tgz",
-      "integrity": "sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-arm64-gnu": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.30.2.tgz",
-      "integrity": "sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-arm64-musl": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.30.2.tgz",
-      "integrity": "sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-x64-gnu": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.30.2.tgz",
-      "integrity": "sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-linux-x64-musl": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.30.2.tgz",
-      "integrity": "sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-win32-arm64-msvc": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.30.2.tgz",
-      "integrity": "sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/lightningcss-win32-x64-msvc": {
-      "version": "1.30.2",
-      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.30.2.tgz",
-      "integrity": "sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MPL-2.0",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">= 12.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
     "node_modules/longest-streak": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
@@ -6659,6 +5802,16 @@
         "url": "https://opencollective.com/webpack"
       }
     },
+    "node_modules/tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      }
+    },
     "node_modules/tldts": {
       "version": "7.0.19",
       "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.0.19.tgz",
diff --git a/ui/package.json b/ui/package.json
index 38c644a0..c945936f 100644
--- a/ui/package.json
+++ b/ui/package.json
@@ -8,7 +8,13 @@
     "dev": "rsbuild dev",
     "dev:mock": "MOLEXP_USE_MOCK=true rsbuild dev",
     "preview": "rsbuild preview",
-    "generate:api": "npx openapi-typescript-codegen --input ../openapi.json --output src/api/generated --client fetch"
+    "generate:api": "npx openapi-typescript-codegen --input ../openapi.json --output src/api/generated --client fetch",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "typecheck": "tsc --noEmit",
+    "test": "rstest run",
+    "test:watch": "rstest watch"
   },
   "dependencies": {
     "@monaco-editor/react": "^4.7.0",
@@ -47,11 +53,13 @@
     "zustand": "^5.0.8"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.11",
     "@rsbuild/core": "^1.6.7",
     "@rsbuild/plugin-react": "^1.4.2",
     "@tailwindcss/postcss": "^4.1.17",
     "@types/react": "^19.2.6",
     "@types/react-dom": "^19.2.3",
+    "@rstest/core": "^0.7.0",
     "msw": "^2.12.3",
     "openapi-typescript-codegen": "^0.30.0",
     "tailwindcss": "^4.1.17",
diff --git a/ui/public/mockServiceWorker.js b/ui/public/mockServiceWorker.js
index 6951ed1c..b0c5a159 100644
--- a/ui/public/mockServiceWorker.js
+++ b/ui/public/mockServiceWorker.js
@@ -7,7 +7,7 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '2.12.3'
+const PACKAGE_VERSION = '2.13.2'
 const INTEGRITY_CHECKSUM = '4db4a41e972cec1b64cc569c66952d82'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 const activeClientIds = new Set()
diff --git a/ui/rsbuild.config.ts b/ui/rsbuild.config.ts
index ea55c43d..7e3dec39 100644
--- a/ui/rsbuild.config.ts
+++ b/ui/rsbuild.config.ts
@@ -25,7 +25,10 @@ export default defineConfig(({ command }) => {
     server: {
       proxy: {
         '/api': {
-          target: 'http://localhost:8080',
+          target: `http://localhost:${(() => {
+            const arg = process.argv.find(a => a.startsWith('--api-port='));
+            return arg ? arg.split('=')[1] : '8000';
+          })()}`,
           changeOrigin: true,
         },
       },
diff --git a/ui/rstest.config.ts b/ui/rstest.config.ts
new file mode 100644
index 00000000..ae7c4d50
--- /dev/null
+++ b/ui/rstest.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from "@rstest/core";
+import { withRsbuildConfig } from "@rstest/adapter-rsbuild";
+
+export default defineConfig({
+  extends: withRsbuildConfig(),
+  browser: {
+    enabled: false,
+  },
+  globals: true,
+  testEnvironment: "node",
+});
diff --git a/ui/src/App.tsx b/ui/src/App.tsx
index cc5e52dc..3f9a155e 100644
--- a/ui/src/App.tsx
+++ b/ui/src/App.tsx
@@ -1,14 +1,11 @@
 import { useEffect, useState } from "react";
-
-import type { InspectorTarget, Selection } from "@/app/types";
 import { AppShell } from "@/app/layout/AppShell";
 import { ErrorBoundary } from "@/app/layout/ErrorBoundary";
-import { registerDefaultRenderers } from "@/app/renderers/registerRenderers";
-import { useUrlState } from "@/app/state/useUrlState";
-import { useWorkspaceState } from "@/app/state/useWorkspaceState";
 import { workspaceApi } from "@/app/state/api";
-
-registerDefaultRenderers();
+import { useNavigationState } from "@/app/state/useNavigationState";
+import { useWorkspaceState } from "@/app/state/useWorkspaceState";
+import type { InspectorTarget, Selection } from "@/app/types";
+import { initializeUiPlugins } from "@/plugins/runtime";
 
 const buildDefaultInspectorTarget = (selection: Selection | null): InspectorTarget => {
   if (!selection) {
@@ -24,7 +21,8 @@ const buildDefaultInspectorTarget = (selection: Selection | null): InspectorTarg
 
 const App = (): JSX.Element => {
   const { snapshot, status, error, refresh } = useWorkspaceState();
-  const { leftPanelView, selection, setLeftPanelView, setSelection } = useUrlState();
+  const { leftPanelView, selection, setLeftPanelView, setSelection } = useNavigationState(snapshot);
+  const [pluginsReady, setPluginsReady] = useState(false);
   const [inspectorTarget, setInspectorTarget] = useState<InspectorTarget>(
     buildDefaultInspectorTarget(selection),
   );
@@ -33,10 +31,40 @@ const App = (): JSX.Element => {
     setInspectorTarget(buildDefaultInspectorTarget(selection));
   }, [selection]);
 
+  useEffect(() => {
+    let cancelled = false;
+
+    initializeUiPlugins()
+      .catch((pluginError) => {
+        console.warn("Failed to initialize UI plugins:", pluginError);
+      })
+      .finally(() => {
+        if (!cancelled) {
+          setPluginsReady(true);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
   if (error) {
     throw error;
   }
 
+  if (!pluginsReady) {
+    return (
+      <ErrorBoundary>
+        <div className="flex h-screen items-center justify-center bg-background text-foreground">
+          <div className="rounded-md border border-border bg-background px-4 py-2 text-sm text-muted-foreground">
+            Loading interface plugins...
+          </div>
+        </div>
+      </ErrorBoundary>
+    );
+  }
+
   const handleSelectionChange = (nextSelection: Selection): void => {
     setSelection(nextSelection);
   };
diff --git a/ui/src/__fixtures__/api.ts b/ui/src/__fixtures__/api.ts
new file mode 100644
index 00000000..b97917c3
--- /dev/null
+++ b/ui/src/__fixtures__/api.ts
@@ -0,0 +1,121 @@
+/**
+ * Shared fixture data for unit tests.
+ * Equivalent role to Python's conftest.py — import from here, do not inline in test files.
+ */
+
+import type { AssetResponse } from "@/api/generated/models/AssetResponse";
+import type { ExperimentResponse } from "@/api/generated/models/ExperimentResponse";
+import type { ProjectResponse } from "@/api/generated/models/ProjectResponse";
+import type { RunResponse } from "@/api/generated/models/RunResponse";
+import type { ExperimentSummary, ProjectSummary, RunSummary } from "@/app/types";
+
+export const fixtureProject: ProjectResponse = {
+  id: "proj-alpha",
+  projectId: "proj-alpha",
+  name: "Alpha Project",
+  created: "2026-03-01T00:00:00Z",
+  description: "First project",
+};
+
+export const fixtureProjectNoDescription: ProjectResponse = {
+  id: "proj-beta",
+  projectId: "proj-beta",
+  name: "Beta Project",
+  created: "2026-03-02T00:00:00Z",
+};
+
+export const fixtureExperiment: ExperimentResponse = {
+  id: "exp-001",
+  experimentId: "exp-001",
+  projectId: "proj-alpha",
+  name: "Baseline",
+  created: "2026-03-01T10:00:00Z",
+  workflow: "workflow.py",
+  description: "Baseline experiment",
+};
+
+export const fixtureExperimentNoDescription: ExperimentResponse = {
+  id: "exp-002",
+  experimentId: "exp-002",
+  projectId: "proj-alpha",
+  name: "Variant",
+  created: "2026-03-02T10:00:00Z",
+  workflow: "variant.py",
+};
+
+export const fixtureRun: RunResponse = {
+  id: "run-abc",
+  runId: "run-abc",
+  projectId: "proj-alpha",
+  experimentId: "exp-001",
+  status: "succeeded",
+  created: "2026-03-01T11:00:00Z",
+  finished: "2026-03-01T12:00:00Z",
+  parameters: { lr: 0.001 },
+};
+
+export const fixtureRunPending: RunResponse = {
+  id: "run-def",
+  runId: "run-def",
+  projectId: "proj-alpha",
+  experimentId: "exp-001",
+  status: "pending",
+  created: "2026-03-01T13:00:00Z",
+};
+
+export const fixtureRunFailed: RunResponse = {
+  id: "run-ghi",
+  runId: "run-ghi",
+  projectId: "proj-alpha",
+  experimentId: "exp-001",
+  status: "failed",
+  created: "2026-03-01T14:00:00Z",
+};
+
+export const fixtureRunCancelled: RunResponse = {
+  id: "run-jkl",
+  runId: "run-jkl",
+  projectId: "proj-alpha",
+  experimentId: "exp-001",
+  status: "cancelled",
+  created: "2026-03-01T15:00:00Z",
+};
+
+export const fixtureAsset: AssetResponse = {
+  id: "asset-001",
+  assetId: "asset-001",
+  type: "model",
+  format: "pickle",
+  created: "2026-03-01T16:00:00Z",
+  size: 1024,
+  contentHash: "abc123def456",
+};
+
+export const fixtureProjectSummary: ProjectSummary = {
+  id: "proj-alpha",
+  name: "Alpha Project",
+  status: "active",
+  summary: "First project",
+  updatedAt: "2026-03-01T00:00:00Z",
+};
+
+export const fixtureExperimentSummary: ExperimentSummary = {
+  id: "exp-001",
+  name: "Baseline",
+  status: "active",
+  summary: "Baseline experiment",
+  workflowFile: "workflow.py",
+  updatedAt: "2026-03-01T10:00:00Z",
+  projectId: "proj-alpha",
+};
+
+export const fixtureRunSummary: RunSummary = {
+  id: "run-abc",
+  name: "run-abc",
+  status: "succeeded",
+  summary: "Status: succeeded",
+  updatedAt: "2026-03-01T12:00:00Z",
+  projectId: "proj-alpha",
+  experimentId: "exp-001",
+  executorInfo: { backend: "local" },
+};
diff --git a/ui/src/api/generated/index.ts b/ui/src/api/generated/index.ts
index efe9a1e1..4eac6b9b 100644
--- a/ui/src/api/generated/index.ts
+++ b/ui/src/api/generated/index.ts
@@ -7,7 +7,12 @@ export { CancelablePromise, CancelError } from './core/CancelablePromise';
 export { OpenAPI } from './core/OpenAPI';
 export type { OpenAPIConfig } from './core/OpenAPI';
 
+export type { AgentSessionResponse } from './models/AgentSessionResponse';
+export type { SessionEventResponse } from './models/SessionEventResponse';
 export type { AssetFileResponse } from './models/AssetFileResponse';
+export type { CacheClearResponse } from './models/CacheClearResponse';
+export type { CacheStatsResponse } from './models/CacheStatsResponse';
+export type { TaskSnapshotResponse } from './models/TaskSnapshotResponse';
 export type { AssetRefResponse } from './models/AssetRefResponse';
 export type { AssetRefsResponse } from './models/AssetRefsResponse';
 export type { AssetResponse } from './models/AssetResponse';
diff --git a/ui/src/api/generated/models/AgentSessionResponse.ts b/ui/src/api/generated/models/AgentSessionResponse.ts
new file mode 100644
index 00000000..f5e8ff48
--- /dev/null
+++ b/ui/src/api/generated/models/AgentSessionResponse.ts
@@ -0,0 +1,15 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { SessionEventResponse } from './SessionEventResponse';
+/**
+ * Agent session response.
+ */
+export type AgentSessionResponse = {
+    sessionId: string;
+    status: string;
+    goalDescription: string;
+    createdAt: string;
+    events: Array<SessionEventResponse>;
+};
diff --git a/ui/src/api/generated/models/CacheClearResponse.ts b/ui/src/api/generated/models/CacheClearResponse.ts
new file mode 100644
index 00000000..b411c944
--- /dev/null
+++ b/ui/src/api/generated/models/CacheClearResponse.ts
@@ -0,0 +1,10 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Response for cache clear operation.
+ */
+export type CacheClearResponse = {
+    removedCount: number;
+};
diff --git a/ui/src/api/generated/models/CacheStatsResponse.ts b/ui/src/api/generated/models/CacheStatsResponse.ts
new file mode 100644
index 00000000..386b8895
--- /dev/null
+++ b/ui/src/api/generated/models/CacheStatsResponse.ts
@@ -0,0 +1,11 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Cache statistics response.
+ */
+export type CacheStatsResponse = {
+    storeDir: string;
+    entryCount: number;
+};
diff --git a/ui/src/api/generated/models/ExecutionPlanResponse.ts b/ui/src/api/generated/models/ExecutionPlanResponse.ts
index 656b7075..bc964399 100644
--- a/ui/src/api/generated/models/ExecutionPlanResponse.ts
+++ b/ui/src/api/generated/models/ExecutionPlanResponse.ts
@@ -2,11 +2,12 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { TaskSnapshotResponse } from './TaskSnapshotResponse';
 /**
  * Execution plan response.
  */
 export type ExecutionPlanResponse = {
     plan: Array<string>;
     nodeCount: number;
+    snapshots?: Array<TaskSnapshotResponse>;
 };
-
diff --git a/ui/src/api/generated/models/SessionEventResponse.ts b/ui/src/api/generated/models/SessionEventResponse.ts
new file mode 100644
index 00000000..f7a4a7f6
--- /dev/null
+++ b/ui/src/api/generated/models/SessionEventResponse.ts
@@ -0,0 +1,12 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Single agent session event.
+ */
+export type SessionEventResponse = {
+    type: string;
+    ts: string;
+    payload: Record<string, any>;
+};
diff --git a/ui/src/api/generated/models/TaskSnapshotResponse.ts b/ui/src/api/generated/models/TaskSnapshotResponse.ts
new file mode 100644
index 00000000..806ec920
--- /dev/null
+++ b/ui/src/api/generated/models/TaskSnapshotResponse.ts
@@ -0,0 +1,17 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Task snapshot response.
+ */
+export type TaskSnapshotResponse = {
+    taskId: string;
+    taskType: string;
+    codeHash: string;
+    configHash: string;
+    codeSource?: string;
+    snapshotKey: string;
+    createdAt: string;
+    configData?: Record<string, any>;
+};
diff --git a/ui/src/api/generated/services/ExecutionService.ts b/ui/src/api/generated/services/ExecutionService.ts
index 20cb27fb..ca14429d 100644
--- a/ui/src/api/generated/services/ExecutionService.ts
+++ b/ui/src/api/generated/services/ExecutionService.ts
@@ -2,6 +2,8 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { CacheClearResponse } from '../models/CacheClearResponse';
+import type { CacheStatsResponse } from '../models/CacheStatsResponse';
 import type { ExecutionCreateRequest } from '../models/ExecutionCreateRequest';
 import type { ExecutionPlanRequest } from '../models/ExecutionPlanRequest';
 import type { ExecutionPlanResponse } from '../models/ExecutionPlanResponse';
@@ -50,4 +52,28 @@ export class ExecutionService {
             },
         });
     }
+    /**
+     * Get Cache Stats
+     * Get cache statistics.
+     * @returns CacheStatsResponse Successful Response
+     * @throws ApiError
+     */
+    public static getCacheStatsApiCacheStatsGet(): CancelablePromise<CacheStatsResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/cache/stats',
+        });
+    }
+    /**
+     * Clear Cache
+     * Clear all cache entries.
+     * @returns CacheClearResponse Successful Response
+     * @throws ApiError
+     */
+    public static clearCacheApiCacheDelete(): CancelablePromise<CacheClearResponse> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/cache',
+        });
+    }
 }
diff --git a/ui/src/app/components/CreateExperimentDialog.tsx b/ui/src/app/components/CreateExperimentDialog.tsx
index c5fcba91..eb4d6983 100644
--- a/ui/src/app/components/CreateExperimentDialog.tsx
+++ b/ui/src/app/components/CreateExperimentDialog.tsx
@@ -1,5 +1,6 @@
-import { useState } from "react";
 import { Plus } from "lucide-react";
+import { useState } from "react";
+import { workspaceApi } from "@/app/state/api";
 import { Button } from "@/components/ui/button";
 import {
   Dialog,
@@ -13,7 +14,6 @@ import {
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Textarea } from "@/components/ui/textarea";
-import { workspaceApi } from "@/app/state/api";
 
 interface CreateExperimentDialogProps {
   projectId: string;
@@ -118,11 +118,7 @@ export function CreateExperimentDialog({
                 rows={4}
               />
             </div>
-            {error && (
-              <div className="text-sm text-red-500 col-span-4 text-center">
-                {error}
-              </div>
-            )}
+            {error && <div className="text-sm text-red-500 col-span-4 text-center">{error}</div>}
           </div>
           <DialogFooter>
             <Button type="submit" disabled={isLoading}>
diff --git a/ui/src/app/components/CreateProjectDialog.tsx b/ui/src/app/components/CreateProjectDialog.tsx
index a9bce433..2aa39280 100644
--- a/ui/src/app/components/CreateProjectDialog.tsx
+++ b/ui/src/app/components/CreateProjectDialog.tsx
@@ -1,5 +1,6 @@
-import { useState } from "react";
 import { Plus } from "lucide-react";
+import { useState } from "react";
+import { workspaceApi } from "@/app/state/api";
 import { Button } from "@/components/ui/button";
 import {
   Dialog,
@@ -12,7 +13,6 @@ import {
 } from "@/components/ui/dialog";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
-import { workspaceApi } from "@/app/state/api";
 
 interface CreateProjectDialogProps {
   onProjectCreated: () => void;
@@ -54,17 +54,14 @@ export function CreateProjectDialog({ onProjectCreated }: CreateProjectDialogPro
   return (
     <Dialog open={open} onOpenChange={setOpen}>
       <DialogTrigger asChild>
-        <Button variant="outline" size="sm" className="h-7 gap-1">
-          <Plus className="h-3.5 w-3.5" />
-          <span className="sr-only sm:not-sr-only sm:whitespace-nowrap">New Project</span>
+        <Button variant="ghost" size="icon" className="h-7 w-7" aria-label="New project">
+          <Plus className="h-4 w-4" />
         </Button>
       </DialogTrigger>
       <DialogContent className="sm:max-w-[425px]">
         <DialogHeader>
           <DialogTitle>Create Project</DialogTitle>
-          <DialogDescription>
-            Create a new project to organize your experiments.
-          </DialogDescription>
+          <DialogDescription>Create a new project to organize your experiments.</DialogDescription>
         </DialogHeader>
         <form onSubmit={handleSubmit}>
           <div className="grid gap-4 py-4">
@@ -92,11 +89,7 @@ export function CreateProjectDialog({ onProjectCreated }: CreateProjectDialogPro
                 className="col-span-3"
               />
             </div>
-            {error && (
-              <div className="text-sm text-red-500 col-span-4 text-center">
-                {error}
-              </div>
-            )}
+            {error && <div className="text-sm text-red-500 col-span-4 text-center">{error}</div>}
           </div>
           <DialogFooter>
             <Button type="submit" disabled={isLoading}>
diff --git a/ui/src/app/components/CreateRunDialog.tsx b/ui/src/app/components/CreateRunDialog.tsx
index b0517147..a35168bf 100644
--- a/ui/src/app/components/CreateRunDialog.tsx
+++ b/ui/src/app/components/CreateRunDialog.tsx
@@ -1,5 +1,6 @@
-import { useState } from "react";
 import { Play } from "lucide-react";
+import { useState } from "react";
+import { workspaceApi } from "@/app/state/api";
 import { Button } from "@/components/ui/button";
 import {
   Dialog,
@@ -13,7 +14,6 @@ import {
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Textarea } from "@/components/ui/textarea";
-import { workspaceApi } from "@/app/state/api";
 
 interface CreateRunDialogProps {
   projectId: string;
@@ -68,9 +68,7 @@ export function CreateRunDialog({
       <DialogContent className="sm:max-w-[500px]">
         <DialogHeader>
           <DialogTitle>Launch Run</DialogTitle>
-          <DialogDescription>
-            Execute workflow for experiment {experimentId}.
-          </DialogDescription>
+          <DialogDescription>Execute workflow for experiment {experimentId}.</DialogDescription>
         </DialogHeader>
         <form onSubmit={handleSubmit}>
           <div className="grid gap-4 py-4">
@@ -97,7 +95,7 @@ export function CreateRunDialog({
                 rows={6}
               />
             </div>
-             <div className="grid grid-cols-4 items-center gap-4">
+            <div className="grid grid-cols-4 items-center gap-4">
               <Label htmlFor="git-commit" className="text-right">
                 Commit
               </Label>
@@ -109,11 +107,7 @@ export function CreateRunDialog({
                 className="col-span-3"
               />
             </div>
-            {error && (
-              <div className="text-sm text-red-500 col-span-4 text-center">
-                {error}
-              </div>
-            )}
+            {error && <div className="text-sm text-red-500 col-span-4 text-center">{error}</div>}
           </div>
           <DialogFooter>
             <Button type="submit" disabled={isLoading}>
diff --git a/ui/src/app/components/entity/DataTable.tsx b/ui/src/app/components/entity/DataTable.tsx
new file mode 100644
index 00000000..781ff294
--- /dev/null
+++ b/ui/src/app/components/entity/DataTable.tsx
@@ -0,0 +1,72 @@
+import type { JSX, ReactNode } from "react";
+
+export interface DataTableColumn<T> {
+  key: string;
+  header: ReactNode;
+  width?: string;
+  align?: "left" | "right";
+  cell: (row: T) => ReactNode;
+}
+
+export interface DataTableProps<T> {
+  columns: DataTableColumn<T>[];
+  data: T[];
+  getRowKey: (row: T) => string;
+  onRowClick?: (row: T) => void;
+  empty: ReactNode;
+  rowClassName?: (row: T) => string;
+}
+
+export const DataTable = <T,>({
+  columns,
+  data,
+  getRowKey,
+  onRowClick,
+  empty,
+  rowClassName,
+}: DataTableProps<T>): JSX.Element => {
+  return (
+    <div className="flex-1 overflow-auto">
+      <table className="w-full text-left text-sm">
+        <thead className="sticky top-0 z-10 border-b border-border bg-muted/40 text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+          <tr>
+            {columns.map((col) => (
+              <th
+                key={col.key}
+                className={`px-3 py-1.5 ${col.width ?? "w-auto"} ${col.align === "right" ? "text-right" : ""}`}
+              >
+                {col.header}
+              </th>
+            ))}
+          </tr>
+        </thead>
+        <tbody className="divide-y divide-border/50">
+          {data.length === 0 ? (
+            <tr>
+              <td colSpan={columns.length} className="py-10">
+                {empty}
+              </td>
+            </tr>
+          ) : (
+            data.map((row) => (
+              <tr
+                key={getRowKey(row)}
+                className={`group transition-colors hover:bg-accent/50 ${onRowClick ? "cursor-pointer" : ""} ${rowClassName?.(row) ?? ""}`}
+                onClick={onRowClick ? () => onRowClick(row) : undefined}
+              >
+                {columns.map((col) => (
+                  <td
+                    key={col.key}
+                    className={`px-3 py-1.5 ${col.align === "right" ? "text-right" : ""}`}
+                  >
+                    {col.cell(row)}
+                  </td>
+                ))}
+              </tr>
+            ))
+          )}
+        </tbody>
+      </table>
+    </div>
+  );
+};
diff --git a/ui/src/app/components/entity/EmptyState.tsx b/ui/src/app/components/entity/EmptyState.tsx
new file mode 100644
index 00000000..080dc9bc
--- /dev/null
+++ b/ui/src/app/components/entity/EmptyState.tsx
@@ -0,0 +1,46 @@
+import type { JSX, ReactNode } from "react";
+
+export type EmptyStateDensity = "default" | "compact" | "inline";
+
+export interface EmptyStateProps {
+  title: string;
+  description?: string;
+  action?: ReactNode;
+  icon?: ReactNode;
+  density?: EmptyStateDensity;
+}
+
+const CONTAINER: Record<EmptyStateDensity, string> = {
+  default: "flex flex-col items-center gap-2 py-12 text-center",
+  compact: "flex flex-col items-center gap-2 py-6 text-center",
+  inline: "px-2 py-1 text-left",
+};
+
+const TITLE: Record<EmptyStateDensity, string> = {
+  default: "text-sm text-muted-foreground",
+  compact: "text-xs text-muted-foreground",
+  inline: "text-xs text-muted-foreground",
+};
+
+const DESCRIPTION: Record<EmptyStateDensity, string> = {
+  default: "text-xs text-muted-foreground/70",
+  compact: "text-[11px] text-muted-foreground/70",
+  inline: "text-[11px] text-muted-foreground/70",
+};
+
+export const EmptyState = ({
+  title,
+  description,
+  action,
+  icon,
+  density = "default",
+}: EmptyStateProps): JSX.Element => {
+  return (
+    <div className={CONTAINER[density]}>
+      {icon && <div className="text-muted-foreground/40">{icon}</div>}
+      <p className={TITLE[density]}>{title}</p>
+      {description && <p className={DESCRIPTION[density]}>{description}</p>}
+      {action && <div className="mt-2">{action}</div>}
+    </div>
+  );
+};
diff --git a/ui/src/app/components/entity/EntityPage.tsx b/ui/src/app/components/entity/EntityPage.tsx
new file mode 100644
index 00000000..9d71803a
--- /dev/null
+++ b/ui/src/app/components/entity/EntityPage.tsx
@@ -0,0 +1,173 @@
+import { ChevronLeft, ChevronRight } from "lucide-react";
+import type { ComponentType, JSX, ReactNode } from "react";
+import { Link } from "react-router-dom";
+import type { BreadcrumbItem, SemanticStatus } from "@/app/types";
+import { StatusBadge } from "./StatusBadge";
+
+interface SemanticStatusBadgeProps {
+  status: SemanticStatus;
+}
+
+export const SemanticStatusBadge = ({ status }: SemanticStatusBadgeProps): JSX.Element => {
+  return <StatusBadge status={status} />;
+};
+
+interface EntityMetricProps {
+  label: string;
+  value: number | string;
+}
+
+export const EntityMetric = ({ label, value }: EntityMetricProps): JSX.Element => {
+  return (
+    <span className="flex items-baseline gap-1 text-xs">
+      <span className="font-semibold tabular-nums text-foreground">{value}</span>
+      <span className="text-muted-foreground">{label}</span>
+    </span>
+  );
+};
+
+interface HeaderBreadcrumbProps {
+  items: BreadcrumbItem[];
+  canNavigateUp?: boolean;
+  onNavigateUp?: () => void;
+}
+
+const HeaderBreadcrumb = ({
+  items,
+  canNavigateUp,
+  onNavigateUp,
+}: HeaderBreadcrumbProps): JSX.Element => {
+  return (
+    <div className="flex items-center gap-1 text-xs text-muted-foreground">
+      {onNavigateUp && (
+        <button
+          type="button"
+          onClick={onNavigateUp}
+          disabled={!canNavigateUp}
+          aria-label="Back"
+          className="flex h-6 w-6 items-center justify-center rounded-sm transition-colors hover:bg-muted/60 hover:text-foreground disabled:opacity-40"
+        >
+          <ChevronLeft className="h-3.5 w-3.5" />
+        </button>
+      )}
+      <nav className="flex min-w-0 flex-wrap items-center gap-1">
+        {items.map((item, index) => {
+          const isLast = index === items.length - 1;
+          return (
+            <span
+              key={`${item.label}-${item.to ?? index}`}
+              className="flex min-w-0 items-center gap-1"
+            >
+              {item.to && !isLast ? (
+                <Link
+                  to={item.to}
+                  className="truncate rounded-sm px-1 py-0.5 transition-colors hover:bg-muted/60 hover:text-foreground"
+                >
+                  {item.label}
+                </Link>
+              ) : (
+                <span className={isLast ? "truncate text-foreground" : "truncate"}>
+                  {item.label}
+                </span>
+              )}
+              {!isLast && <ChevronRight className="h-3 w-3 flex-none opacity-50" />}
+            </span>
+          );
+        })}
+      </nav>
+    </div>
+  );
+};
+
+interface EntityHeaderProps {
+  breadcrumbs?: BreadcrumbItem[];
+  canNavigateUp?: boolean;
+  onNavigateUp?: () => void;
+  icon: ComponentType<{ className?: string }>;
+  title: string;
+  subtitle?: string;
+  status?: string;
+  actions?: ReactNode;
+  metrics?: ReactNode;
+}
+
+export const EntityHeader = ({
+  breadcrumbs,
+  canNavigateUp,
+  onNavigateUp,
+  icon: Icon,
+  title,
+  subtitle,
+  status,
+  actions,
+  metrics,
+}: EntityHeaderProps): JSX.Element => {
+  return (
+    <section className="border-b border-border/70 bg-background">
+      <div className="px-4 pt-2">
+        {breadcrumbs && breadcrumbs.length > 0 && (
+          <HeaderBreadcrumb
+            items={breadcrumbs}
+            canNavigateUp={canNavigateUp}
+            onNavigateUp={onNavigateUp}
+          />
+        )}
+
+        <div className="mt-1.5 flex items-center justify-between gap-4 pb-2.5">
+          <div className="flex min-w-0 flex-1 items-center gap-2.5">
+            <div className="flex h-7 w-7 flex-none items-center justify-center rounded-md bg-muted">
+              <Icon className="h-4 w-4 text-foreground" />
+            </div>
+            <div className="flex min-w-0 flex-1 items-center gap-2">
+              <h2 className="truncate text-base font-semibold text-foreground">{title}</h2>
+              {status && <StatusBadge status={status} />}
+              {subtitle && (
+                <span
+                  className="hidden min-w-0 truncate text-xs text-muted-foreground md:inline"
+                  title={subtitle}
+                >
+                  · {subtitle}
+                </span>
+              )}
+            </div>
+          </div>
+
+          {(actions || metrics) && (
+            <div className="flex flex-none items-center gap-4">
+              {metrics && (
+                <div className="flex flex-wrap items-baseline justify-end gap-x-3 gap-y-0.5">
+                  {metrics}
+                </div>
+              )}
+              {actions && <div className="flex items-center gap-1">{actions}</div>}
+            </div>
+          )}
+        </div>
+      </div>
+    </section>
+  );
+};
+
+interface KeyValueItem {
+  label: string;
+  value: ReactNode;
+}
+
+interface KeyValueGridProps {
+  items: KeyValueItem[];
+}
+
+export const KeyValueGrid = ({ items }: KeyValueGridProps): JSX.Element => {
+  return (
+    <dl className="grid gap-x-6 gap-y-2 md:grid-cols-2">
+      {items.map((item) => (
+        <div key={item.label} className="flex min-w-0 flex-col">
+          <dt className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+            {item.label}
+          </dt>
+          <dd className="mt-0.5 min-w-0 truncate text-sm text-foreground">{item.value}</dd>
+        </div>
+      ))}
+    </dl>
+  );
+};
diff --git a/ui/src/app/components/entity/StatusBadge.tsx b/ui/src/app/components/entity/StatusBadge.tsx
new file mode 100644
index 00000000..279e1eb6
--- /dev/null
+++ b/ui/src/app/components/entity/StatusBadge.tsx
@@ -0,0 +1,54 @@
+import type { JSX } from "react";
+
+export type StatusTone = "success" | "error" | "running" | "neutral" | "warning";
+
+const STATUS_TONE: Record<string, StatusTone> = {
+  active: "success",
+  succeeded: "success",
+  completed: "success",
+  failed: "error",
+  error: "error",
+  running: "running",
+  pending: "neutral",
+  archived: "neutral",
+  cancelled: "neutral",
+  draft: "warning",
+  skipped: "warning",
+};
+
+const TONE_SOFT: Record<StatusTone, string> = {
+  success: "border-success/25 bg-success-soft text-success-foreground",
+  error: "border-destructive/25 bg-destructive/10 text-destructive",
+  running: "border-info/25 bg-info-soft text-info-foreground",
+  neutral: "border-border bg-muted text-muted-foreground",
+  warning: "border-warning/25 bg-warning-soft text-warning-foreground",
+};
+
+const SIZE_CLASS: Record<StatusBadgeSize, string> = {
+  sm: "px-1.5 py-0 text-[10px]",
+  md: "px-2 py-0.5 text-xs",
+};
+
+export type StatusBadgeSize = "sm" | "md";
+
+export interface StatusBadgeProps {
+  status: string;
+  size?: StatusBadgeSize;
+  pulse?: boolean;
+}
+
+const resolveTone = (status: string): StatusTone => {
+  return STATUS_TONE[status.toLowerCase()] ?? "neutral";
+};
+
+export const StatusBadge = ({ status, size = "md", pulse }: StatusBadgeProps): JSX.Element => {
+  const tone = resolveTone(status);
+  const shouldPulse = pulse ?? tone === "running";
+  return (
+    <span
+      className={`inline-flex items-center rounded-full border font-medium ${TONE_SOFT[tone]} ${SIZE_CLASS[size]} ${shouldPulse ? "animate-pulse" : ""}`}
+    >
+      {status}
+    </span>
+  );
+};
diff --git a/ui/src/app/components/entity/density.ts b/ui/src/app/components/entity/density.ts
new file mode 100644
index 00000000..e0dcb808
--- /dev/null
+++ b/ui/src/app/components/entity/density.ts
@@ -0,0 +1,12 @@
+export const ROW_PADDING_DEFAULT = "py-3 px-6";
+export const ROW_PADDING_COMPACT = "py-1.5 px-2";
+
+export const DIVIDE_Y = "divide-y divide-border/50";
+
+export const TABLE_HEADER =
+  "sticky top-0 border-b border-border/70 bg-background text-muted-foreground text-muted-foreground";
+
+export const ROW_HOVER = "group hover:bg-muted/40 transition-colors";
+
+export const EMPTY_BLOCK = "py-12 text-center text-muted-foreground";
+export const EMPTY_BLOCK_COMPACT = "py-6 text-center text-muted-foreground";
diff --git a/ui/src/app/components/entity/emptyStateCopy.ts b/ui/src/app/components/entity/emptyStateCopy.ts
new file mode 100644
index 00000000..87ed03c9
--- /dev/null
+++ b/ui/src/app/components/entity/emptyStateCopy.ts
@@ -0,0 +1,34 @@
+export const EMPTY_COPY = {
+  experiments: {
+    title: "No experiments yet.",
+    description: 'Click "Create Experiment" to start.',
+  },
+  runs: {
+    title: "No runs yet.",
+    description: 'Click "Start Run" to begin.',
+  },
+  projectRuns: {
+    title: "No runs yet.",
+    description: "No runs have been created for this project.",
+  },
+  assets: {
+    title: "No assets yet.",
+    description: "No assets have been recorded here.",
+  },
+  entries: {
+    title: "No entries available.",
+  },
+  projectsFilter: {
+    title: "No projects match the current filter.",
+  },
+  workspace: {
+    title: "No workspace files loaded.",
+  },
+  emptyFolder: {
+    title: "Empty folder",
+  },
+  agentSessions: {
+    title: "No sessions yet.",
+    description: "Start a new goal to create one.",
+  },
+} as const;
diff --git a/ui/src/app/components/entity/index.ts b/ui/src/app/components/entity/index.ts
new file mode 100644
index 00000000..35517310
--- /dev/null
+++ b/ui/src/app/components/entity/index.ts
@@ -0,0 +1,8 @@
+export type { DataTableColumn, DataTableProps } from "./DataTable";
+export { DataTable } from "./DataTable";
+export type { EmptyStateDensity, EmptyStateProps } from "./EmptyState";
+export { EmptyState } from "./EmptyState";
+export { EntityHeader, EntityMetric, KeyValueGrid } from "./EntityPage";
+export { EMPTY_COPY } from "./emptyStateCopy";
+export type { StatusBadgeProps, StatusBadgeSize, StatusTone } from "./StatusBadge";
+export { StatusBadge } from "./StatusBadge";
diff --git a/ui/src/app/layout/AppShell.tsx b/ui/src/app/layout/AppShell.tsx
index ee812b2c..727f5542 100644
--- a/ui/src/app/layout/AppShell.tsx
+++ b/ui/src/app/layout/AppShell.tsx
@@ -1,10 +1,10 @@
 import { useState } from "react";
-import { ResizableHandle, ResizablePanel, ResizablePanelGroup } from "@/components/ui/resizable";
-import type { InspectorTarget, Selection, WorkspaceSnapshot } from "@/app/types";
-import { TopBar } from "@/app/layout/TopBar";
-import { LeftPanel } from "@/app/panels/LeftPanel";
+import { ContextBar } from "@/app/layout/ContextBar";
 import { CenterPanel } from "@/app/panels/CenterPanel";
-import type { LeftPanelView } from "@/app/types";
+import { LeftPanel } from "@/app/panels/LeftPanel";
+import { RightPanel } from "@/app/panels/RightPanel";
+import type { InspectorTarget, LeftPanelView, Selection, WorkspaceSnapshot } from "@/app/types";
+import { ResizableHandle, ResizablePanel, ResizablePanelGroup } from "@/components/ui/resizable";
 
 interface AppShellProps {
   leftPanelView: LeftPanelView;
@@ -21,8 +21,9 @@ interface AppShellProps {
 }
 
 const PANEL_DEFAULTS = {
-  left: 20,
-  center: 80,
+  left: 22,
+  center: 78,
+  right: 20,
 };
 
 export const AppShell = ({
@@ -39,10 +40,17 @@ export const AppShell = ({
   onWorkspaceRefresh,
 }: AppShellProps): JSX.Element => {
   const [searchQuery, setSearchQuery] = useState("");
+  const [inspectorOpen, setInspectorOpen] = useState(false);
 
   return (
     <div className="flex h-screen flex-col bg-background text-foreground">
-      <TopBar searchQuery={searchQuery} onSearchChange={setSearchQuery} />
+      <ContextBar
+        inspectorOpen={inspectorOpen}
+        searchQuery={searchQuery}
+        selectionActive={Boolean(selection)}
+        onSearchChange={setSearchQuery}
+        onToggleInspector={() => setInspectorOpen((current) => !current)}
+      />
       <main className="flex flex-1 flex-col overflow-hidden">
         <ResizablePanelGroup direction="horizontal" className="flex-1">
           <ResizablePanel defaultSize={PANEL_DEFAULTS.left} minSize={16} maxSize={30}>
@@ -71,6 +79,22 @@ export const AppShell = ({
               />
             </div>
           </ResizablePanel>
+          {inspectorOpen && selection && (
+            <>
+              <ResizableHandle withHandle />
+              <ResizablePanel defaultSize={PANEL_DEFAULTS.right} minSize={16} maxSize={28}>
+                <div className="h-full overflow-hidden border-l border-border/70 bg-muted/10">
+                  <RightPanel
+                    selection={selection}
+                    snapshot={snapshot}
+                    inspectorTarget={inspectorTarget}
+                    onInspectorTargetChange={onInspectorTargetChange}
+                    onRefresh={onWorkspaceRefresh}
+                  />
+                </div>
+              </ResizablePanel>
+            </>
+          )}
         </ResizablePanelGroup>
       </main>
     </div>
diff --git a/ui/src/app/layout/ContextBar.tsx b/ui/src/app/layout/ContextBar.tsx
new file mode 100644
index 00000000..d7d1d467
--- /dev/null
+++ b/ui/src/app/layout/ContextBar.tsx
@@ -0,0 +1,58 @@
+import { PanelRightClose, PanelRightOpen, Search } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+
+interface ContextBarProps {
+  inspectorOpen: boolean;
+  searchQuery: string;
+  selectionActive: boolean;
+  onSearchChange: (query: string) => void;
+  onToggleInspector: () => void;
+}
+
+export const ContextBar = ({
+  inspectorOpen,
+  searchQuery,
+  selectionActive,
+  onSearchChange,
+  onToggleInspector,
+}: ContextBarProps): JSX.Element => {
+  return (
+    <header className="border-b border-border bg-background/95 backdrop-blur">
+      <div className="flex items-center justify-between gap-6 px-4 py-2 md:px-6">
+        <div className="flex items-center gap-2">
+          <div className="flex h-7 w-7 items-center justify-center rounded-md bg-foreground text-xs font-semibold uppercase tracking-[0.2em] text-background">
+            M
+          </div>
+          <span className="text-sm font-semibold tracking-tight text-foreground">molexp</span>
+        </div>
+
+        <div className="flex w-full max-w-md items-center gap-2">
+          <div className="relative flex-1">
+            <Search className="absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
+            <Input
+              className="h-8 pl-9"
+              placeholder="Search projects, experiments, runs, assets"
+              value={searchQuery}
+              onChange={(event) => onSearchChange(event.target.value)}
+            />
+          </div>
+          <Button
+            variant="outline"
+            size="sm"
+            className="h-8 gap-2"
+            onClick={onToggleInspector}
+            disabled={!selectionActive}
+          >
+            {inspectorOpen ? (
+              <PanelRightClose className="h-4 w-4" />
+            ) : (
+              <PanelRightOpen className="h-4 w-4" />
+            )}
+            Details
+          </Button>
+        </div>
+      </div>
+    </header>
+  );
+};
diff --git a/ui/src/app/layout/ErrorBoundary.tsx b/ui/src/app/layout/ErrorBoundary.tsx
index 7c9740f0..5b5d7d34 100644
--- a/ui/src/app/layout/ErrorBoundary.tsx
+++ b/ui/src/app/layout/ErrorBoundary.tsx
@@ -1,6 +1,6 @@
-import { Component } from "react";
-import type { ErrorInfo, ReactNode } from "react";
 import { AlertTriangle } from "lucide-react";
+import type { ErrorInfo, ReactNode } from "react";
+import { Component } from "react";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 
diff --git a/ui/src/app/layout/ExecutionConsole.tsx b/ui/src/app/layout/ExecutionConsole.tsx
index a513da27..8b44f958 100644
--- a/ui/src/app/layout/ExecutionConsole.tsx
+++ b/ui/src/app/layout/ExecutionConsole.tsx
@@ -35,14 +35,12 @@ export const ExecutionConsole = ({ snapshot }: ExecutionConsoleProps): JSX.Eleme
           {snapshot.consoleEntries.length === 0 && (
             <p className="text-xs text-muted-foreground">No execution logs available.</p>
           )}
-          {snapshot.consoleEntries.map(entry => (
+          {snapshot.consoleEntries.map((entry) => (
             <div
               key={entry.id}
               className="flex items-start gap-3 rounded-md border border-border/60 bg-background px-3 py-2"
             >
-              <div className="mt-0.5 text-muted-foreground">
-                {levelIcons[entry.level]}
-              </div>
+              <div className="mt-0.5 text-muted-foreground">{levelIcons[entry.level]}</div>
               <div className="flex-1 space-y-1">
                 <div className="flex items-center gap-2">
                   <Badge className={`${levelStyles[entry.level]} text-xs uppercase`}>
diff --git a/ui/src/app/layout/TopBar.tsx b/ui/src/app/layout/TopBar.tsx
index 5c5e32d3..0540dba7 100644
--- a/ui/src/app/layout/TopBar.tsx
+++ b/ui/src/app/layout/TopBar.tsx
@@ -1,7 +1,6 @@
 import { Bell, Search } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
 
 interface TopBarProps {
   searchQuery?: string;
diff --git a/ui/src/app/panels/CenterPanel.tsx b/ui/src/app/panels/CenterPanel.tsx
index b680e3b2..e8504198 100644
--- a/ui/src/app/panels/CenterPanel.tsx
+++ b/ui/src/app/panels/CenterPanel.tsx
@@ -1,6 +1,10 @@
+import {
+  buildRendererKeyFromSelection,
+  renderPlanByObjectType,
+  resolveRenderer,
+} from "@/app/registry";
+import type { InspectorTarget, Selection, WorkspaceSnapshot } from "@/app/types";
 import { Card } from "@/components/ui/card";
-import { buildRendererKeyFromSelection, renderPlanByObjectType, resolveRenderer } from "@/app/registry";
-import type { InspectorTarget, RendererProps, Selection, WorkspaceSnapshot } from "@/app/types";
 
 interface CenterPanelProps {
   selection: Selection | null;
@@ -29,14 +33,14 @@ export const CenterPanel = ({
   }
 
   const plan = renderPlanByObjectType[selection.objectType];
-  const renderers = plan.center.map(target => {
+  const renderers = plan.center.map((target) => {
     const key = buildRendererKeyFromSelection(selection, target);
-    return resolveRenderer(key);
+    return resolveRenderer(key, { selection, snapshot, target });
   });
 
   return (
     <div className="flex h-full flex-col">
-      {renderers.map(renderer => (
+      {renderers.map((renderer) => (
         <renderer.Component
           key={`${renderer.title}-${renderer.panelSlot}`}
           selection={selection}
diff --git a/ui/src/app/panels/LeftPanel.tsx b/ui/src/app/panels/LeftPanel.tsx
index c6843cba..d597381c 100644
--- a/ui/src/app/panels/LeftPanel.tsx
+++ b/ui/src/app/panels/LeftPanel.tsx
@@ -1,38 +1,36 @@
 import {
   Archive,
   Blocks,
-  ChevronRight,
-  FileText,
+  Bot,
+  Clock,
   FilePlus,
+  FileText,
   FlaskConical,
   Folder,
   FolderOpen,
   FolderPlus,
   FolderTree,
   PlayCircle,
+  Plus,
   RefreshCw,
-  LayoutDashboard,
-  Workflow,
   Settings,
+  Sparkles,
+  Workflow,
 } from "lucide-react";
-import { useEffect, useState, useRef, useMemo } from "react";
-
-import type { SVGProps } from "react";
+import type { ComponentType, SVGProps } from "react";
+import { useEffect, useMemo, useRef } from "react";
+import { CreateProjectDialog } from "@/app/components/CreateProjectDialog";
+import { EMPTY_COPY, StatusBadge } from "@/app/components/entity";
+import type { TreeNode } from "@/app/panels/TreeView";
+import { TreeView } from "@/app/panels/TreeView";
 import type {
-  AssetSummary,
-  ExperimentSummary,
   FileKind,
   LeftPanelView,
-  ProjectSummary,
-  RunSummary,
   Selection,
   SemanticStatus,
   WorkspaceSnapshot,
   WorkspaceTreeNode,
-  WorkflowSummary,
 } from "@/app/types";
-import { CreateProjectDialog } from "@/app/components/CreateProjectDialog";
-import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { ScrollArea } from "@/components/ui/scroll-area";
 import { Separator } from "@/components/ui/separator";
@@ -42,6 +40,7 @@ interface LeftPanelProps {
   view: LeftPanelView;
   selection: Selection | null;
   snapshot: WorkspaceSnapshot;
+  searchQuery?: string;
   onViewChange: (view: LeftPanelView) => void;
   onSelect: (selection: Selection) => void;
   onOpenWorkspace: (path: string) => void;
@@ -53,27 +52,23 @@ interface LeftPanelProps {
 interface ViewOption {
   id: LeftPanelView;
   label: string;
-  icon: (props: SVGProps<SVGSVGElement>) => JSX.Element;
+  icon: ComponentType<SVGProps<SVGSVGElement>>;
 }
 
 const viewOptions: ViewOption[] = [
+  { id: "projects", label: "Projects", icon: Blocks },
   { id: "workspace", label: "Workspace", icon: FolderTree },
-  { id: "project", label: "Project", icon: Blocks },
-  { id: "experiment", label: "Experiment", icon: FlaskConical },
-  { id: "run", label: "Run", icon: PlayCircle }, // Fixed duplicate
   { id: "asset", label: "Asset", icon: Archive },
   { id: "workflow", label: "Workflow", icon: Workflow },
+  { id: "agent", label: "Agent", icon: Bot },
 ];
 
-const statusStyles: Record<SemanticStatus, string> = {
-  active: "bg-emerald-100 text-emerald-900",
-  archived: "bg-slate-200 text-slate-900",
-  draft: "bg-amber-100 text-amber-900",
-  pending: "bg-slate-100 text-slate-900",
-  running: "bg-blue-100 text-blue-900",
-  succeeded: "bg-emerald-100 text-emerald-900",
-  failed: "bg-rose-100 text-rose-900",
-  cancelled: "bg-slate-200 text-slate-900",
+const listHeaderByView: Record<LeftPanelView, string> = {
+  projects: "Projects",
+  workspace: "Workspace",
+  asset: "Assets",
+  workflow: "Workflows",
+  agent: "Agent Sessions",
 };
 
 const fileKindByExtension: Record<string, FileKind> = {
@@ -94,458 +89,266 @@ const detectFileKind = (path: string): FileKind => {
   return fileKindByExtension[extension] ?? "unknown";
 };
 
-const buildListHeader = (view: LeftPanelView): string => {
-  const labelByView: Record<LeftPanelView, string> = {
-    workspace: "Workspace",
-    project: "Projects",
-    experiment: "Experiments",
-    run: "Runs",
-    asset: "Assets",
-    workflow: "Workflows",
-  };
-
-  return labelByView[view];
+const runIconClass = (status: SemanticStatus): string => {
+  switch (status) {
+    case "succeeded":
+      return "text-emerald-500";
+    case "failed":
+      return "text-rose-500";
+    case "running":
+      return "text-blue-500";
+    default:
+      return "text-muted-foreground";
+  }
 };
 
-const WorkspaceTree = ({
-  root,
-  onSelect,
-  activePath,
-  snapshot,
-}: {
-  root: WorkspaceTreeNode | null;
-  onSelect: (selection: Selection) => void;
-  activePath?: string;
-  snapshot: WorkspaceSnapshot;
-}): JSX.Element => {
-  const [expandedIds, setExpandedIds] = useState<Set<string>>(new Set());
-
-  useEffect(() => {
-    if (root) {
-      setExpandedIds(new Set([root.id]));
-    }
-  }, [root]);
-
-  if (!root) {
+const buildProjectNodes = (
+  snapshot: WorkspaceSnapshot,
+  onSelect: (selection: Selection) => void,
+  searchQuery: string,
+): TreeNode[] => {
+  const lowerQuery = searchQuery.toLowerCase().trim();
+
+  const hierarchy = snapshot.projects.map((project) => ({
+    ...project,
+    experiments: snapshot.experiments
+      .filter((experiment) => experiment.projectId === project.id)
+      .map((experiment) => ({
+        ...experiment,
+        runs: snapshot.runs.filter((run) => run.experimentId === experiment.id),
+      })),
+  }));
+
+  const filtered = hierarchy.filter((project) => {
+    if (!lowerQuery) return true;
     return (
-      <div className="space-y-2 text-sm text-muted-foreground">
-        <p>No workspace files loaded.</p>
-      </div>
+      project.name.toLowerCase().includes(lowerQuery) ||
+      project.summary.toLowerCase().includes(lowerQuery) ||
+      project.experiments.some(
+        (experiment) =>
+          experiment.name.toLowerCase().includes(lowerQuery) ||
+          experiment.summary.toLowerCase().includes(lowerQuery) ||
+          experiment.runs.some(
+            (run) =>
+              run.name.toLowerCase().includes(lowerQuery) ||
+              run.id.toLowerCase().includes(lowerQuery) ||
+              run.summary.toLowerCase().includes(lowerQuery),
+          ),
+      )
     );
-  }
+  });
+
+  return filtered.map((project) => ({
+    id: project.id,
+    label: project.name,
+    icon: Blocks,
+    iconClassName: "text-blue-500",
+    meta: project.experiments.length,
+    onSelect: () => onSelect({ objectType: "project", objectId: project.id }),
+    children: project.experiments.map((experiment) => ({
+      id: experiment.id,
+      label: experiment.name,
+      icon: FlaskConical,
+      iconClassName: "text-purple-500",
+      right: <StatusBadge status={experiment.status} size="sm" />,
+      onSelect: () => onSelect({ objectType: "experiment", objectId: experiment.id }),
+      emptyChildLabel: EMPTY_COPY.runs.title,
+      children: experiment.runs.map((run) => ({
+        id: run.id,
+        label: run.name || run.id,
+        icon: PlayCircle,
+        iconClassName: runIconClass(run.status),
+        meta: run.id.substring(0, 8),
+        onSelect: () => onSelect({ objectType: "run", objectId: run.id }),
+      })),
+    })),
+  }));
+};
 
+interface WorkspaceSemantic {
+  type: "project" | "experiment" | "run" | "asset";
+  id: string;
+  icon: ComponentType<{ className?: string }>;
+  iconClass: string;
+}
 
+const detectWorkspaceSemantic = (
+  path: string,
+  snapshot: WorkspaceSnapshot,
+): WorkspaceSemantic | null => {
+  const project = snapshot.projects.find((p) => path.endsWith(`projects/${p.id}`));
+  if (project) {
+    return { type: "project", id: project.id, icon: Blocks, iconClass: "text-blue-500" };
+  }
 
-  const isExpanded = (nodeId: string): boolean => {
-    return expandedIds.has(nodeId);
-  };
+  const experiment = snapshot.experiments.find((e) => path.endsWith(`experiments/${e.id}`));
+  if (experiment) {
+    return {
+      type: "experiment",
+      id: experiment.id,
+      icon: FlaskConical,
+      iconClass: "text-purple-500",
+    };
+  }
 
-  const toggleExpanded = (nodeId: string): void => {
-    setExpandedIds(prev => {
-      const next = new Set(prev);
-      if (next.has(nodeId)) {
-        next.delete(nodeId);
-      } else {
-        next.add(nodeId);
-      }
-      return next;
-    });
-  };
+  const run = snapshot.runs.find((r) => path.endsWith(`runs/${r.id}`));
+  if (run) {
+    return { type: "run", id: run.id, icon: PlayCircle, iconClass: runIconClass(run.status) };
+  }
 
-  // Helper to detect if a node corresponds to a semantic object
-  const getSemanticInfo = (path: string) => {
-    // Check Projects
-    const project = snapshot.projects.find(p => path.endsWith(`projects/${p.id}`));
-    if (project) return { type: 'project' as const, id: project.id, icon: Blocks };
-
-    // Check Experiments
-    const experiment = snapshot.experiments.find(e => path.endsWith(`experiments/${e.id}`));
-    if (experiment) return { type: 'experiment' as const, id: experiment.id, icon: FlaskConical };
-    
-    // Check Runs
-    // Path: .../runs/<rid>
-    const run = snapshot.runs.find(r => path.endsWith(`runs/${r.id}`));
-    if (run) return { type: 'run' as const, id: run.id, icon: PlayCircle, status: run.status };
-
-    // Check Assets (Workspace or Project level)
-    const pathParts = path.split('/');
-    const folderName = pathParts[pathParts.length - 1];
-    const parentName = pathParts.length > 1 ? pathParts[pathParts.length - 2] : null;
-    
-    if (parentName === 'assets') {
-         const asset = snapshot.assets.find(a => a.id === folderName);
-         if (asset) return { type: 'asset' as const, id: asset.id, icon: Archive };
+  const parts = path.split("/");
+  const folderName = parts[parts.length - 1];
+  const parentName = parts.length > 1 ? parts[parts.length - 2] : null;
+  if (parentName === "assets") {
+    const asset = snapshot.assets.find((a) => a.id === folderName);
+    if (asset) {
+      return { type: "asset", id: asset.id, icon: Archive, iconClass: "text-amber-500" };
     }
+  }
 
-    return null;
-  };
+  return null;
+};
 
-  const renderNode = (node: WorkspaceTreeNode, depth: number): JSX.Element => {
-    const isFile = node.kind === "file";
-    const expanded = isExpanded(node.id);
-    const hasChildren = node.children.length > 0;
-    const isActive = activePath === node.path;
-    
-    // Check for semantic meaning
-    const semantic = !isFile ? getSemanticInfo(node.path) : null;
-    const NodeIcon = semantic ? semantic.icon : (isFile ? FileText : (expanded ? FolderOpen : Folder));
-    
-    // Dynamic indentation: 16px per level (standard pl-4 equivalent)
-    // depth 0 = 0px, depth 1 = 16px, etc.
-    const paddingLeft = `${Math.max(0, depth) * 16}px`;
+const buildWorkspaceNodes = (
+  snapshot: WorkspaceSnapshot,
+  onSelect: (selection: Selection) => void,
+): TreeNode[] => {
+  const root = snapshot.workspaceRoot;
+  if (!root) return [];
 
-    return (
-      <div key={node.id} className="space-y-1">
-        <div className="flex items-center gap-1" style={{ paddingLeft }}>
-          {!isFile && (
-            <button
-              type="button"
-              aria-label={expanded ? "Collapse folder" : "Expand folder"}
-              className="flex h-6 w-6 items-center justify-center rounded-sm text-muted-foreground transition-colors hover:bg-muted/40 hover:text-foreground flex-none"
-              onClick={(e) => {
-                 e.stopPropagation();
-                 toggleExpanded(node.id);
-              }}
-            >
-              <ChevronRight
-                className={`h-3.5 w-3.5 transition-transform ${
-                  expanded ? "rotate-90" : "rotate-0"
-                }`}
-              />
-            </button>
-          )}
-          {isFile && <span className="h-6 w-6 flex-none" />}
-          
-          <Button
-            variant={isActive ? "secondary" : "ghost"}
-            className="h-7 flex-1 justify-start text-xs overflow-hidden group" 
-            onClick={() => {
-              if (isFile) {
-                onSelect({
-                  objectType: "workspace-file",
-                  objectId: node.path,
-                  filePath: node.path,
-                  fileKind: detectFileKind(node.path),
-                });
-                return;
-              }
-              
-              if (semantic) {
-                  // Navigate to dashboard without expanding
-                  onSelect({
-                      objectType: semantic.type,
-                      objectId: semantic.id
-                  });
-              } else {
-                  // Default folder behavior: toggle expand
-                  toggleExpanded(node.id);
-              }
-            }}
-            title={node.name}
-          >
-            <NodeIcon className={`mr-2 h-3.5 w-3.5 flex-none ${
-                semantic?.type === 'project' ? 'text-blue-500' : 
-                semantic?.type === 'experiment' ? 'text-purple-500' :
-                semantic?.type === 'run' ? (
-                     semantic.status === 'succeeded' ? 'text-green-500' :
-                     semantic.status === 'failed' ? 'text-red-500' :
-                     semantic.status === 'running' ? 'text-blue-500' : 'text-muted-foreground'
-                ) :
-                semantic?.type === 'asset' ? 'text-amber-500' : ''
-            }`} />
-            <span className="truncate flex-1 text-left">{node.name}</span>
-            
-            {semantic && (
-                 <span className="text-[10px] text-muted-foreground uppercase tracking-tighter ml-auto opacity-50 group-hover:opacity-100 transition-opacity">
-                    {semantic.type.substring(0,3)}
-                 </span>
-            )}
-          </Button>
-        </div>
-        {!isFile && expanded && hasChildren && (
-          <div className="space-y-1">
-            {node.children.map(child => renderNode(child, depth + 1))}
-          </div>
-        )}
-        {!isFile && expanded && !hasChildren && (
-          <div className="text-xs text-muted-foreground pl-8" style={{ paddingLeft: `${(depth + 1) * 16}px` }}>
-            Empty folder
-          </div>
-        )}
-      </div>
-    );
+  const walk = (node: WorkspaceTreeNode): TreeNode => {
+    const isFile = node.kind === "file";
+    const semantic = isFile ? null : detectWorkspaceSemantic(node.path, snapshot);
+
+    const icon = semantic?.icon ?? (isFile ? FileText : Folder);
+    const iconClass = semantic?.iconClass ?? (isFile ? "text-muted-foreground" : "text-foreground");
+
+    return {
+      id: node.id,
+      label: node.name,
+      icon,
+      iconClassName: iconClass,
+      meta: semantic ? (
+        <span className="uppercase tracking-tighter opacity-50 group-hover:opacity-100">
+          {semantic.type.substring(0, 3)}
+        </span>
+      ) : undefined,
+      onSelect: () => {
+        if (isFile) {
+          onSelect({
+            objectType: "workspace-file",
+            objectId: node.path,
+            filePath: node.path,
+            fileKind: detectFileKind(node.path),
+          });
+          return;
+        }
+        if (semantic) {
+          onSelect({ objectType: semantic.type, objectId: semantic.id });
+        }
+      },
+      children: isFile ? undefined : node.children.map(walk),
+      emptyChildLabel: !isFile ? EMPTY_COPY.emptyFolder.title : undefined,
+    };
   };
 
-  return <div className="space-y-1">{renderNode(root, 0)}</div>;
+  return [walk(root)];
 };
 
-const SemanticList = <T extends { id: string; name: string; status: SemanticStatus; summary: string }>(
-  {
-    items,
-    onSelect,
-    objectType,
-    activeId,
-  }: {
-    items: T[];
-    onSelect: (selection: Selection) => void;
-    objectType: "project" | "experiment" | "run" | "asset" | "workflow";
-    activeId?: string;
-  },
-): JSX.Element => {
-  if (items.length === 0) {
-    return <p className="text-xs text-muted-foreground">No entries available.</p>;
-  }
-
-  return (
-    <div className="space-y-3">
-      {items.map(item => (
-        <button
-          key={item.id}
-          type="button"
-          className={`w-full rounded-md border text-left transition-colors ${
-              activeId === item.id 
-              ? "border-primary/50 bg-primary/5" 
-              : "border-border/60 bg-background hover:bg-muted/40"
-          } px-3 py-2 overflow-hidden`}
-          onClick={() => {
-            if (objectType === "workflow") {
-              onSelect({ objectType: "workflow", objectId: item.id, workflowId: item.id });
-              return;
-            }
-            onSelect({ objectType, objectId: item.id });
-          }}
-        >
-          <div className="flex items-start justify-between gap-2">
-            <div className="min-w-0 flex-1">
-              <p className="text-sm font-semibold text-foreground truncate" title={item.name}>{item.name}</p>
-              <p className="text-xs text-muted-foreground truncate" title={item.summary}>{item.summary}</p>
-            </div>
-            <Badge className={`mt-0.5 flex-none ${statusStyles[item.status]}`}>{item.status}</Badge>
-          </div>
-        </button>
-      ))}
-    </div>
+const filterBySearch = <T extends { name: string; summary?: string }>(
+  items: T[],
+  searchQuery: string,
+): T[] => {
+  if (!searchQuery) return items;
+  const lower = searchQuery.toLowerCase();
+  return items.filter(
+    (item) =>
+      item.name.toLowerCase().includes(lower) || item.summary?.toLowerCase().includes(lower),
   );
 };
 
-const RunTree = ({
-  snapshot,
-  onSelect,
-  activeId,
-  searchQuery,
-}: {
-  snapshot: WorkspaceSnapshot;
-  onSelect: (selection: Selection) => void;
-  activeId?: string;
-  searchQuery?: string;
-}): JSX.Element => {
-  const [expandedIds, setExpandedIds] = useState<Set<string>>(new Set());
-
-  // Build Hierarchy
-  const hierarchy = useMemo(() => {
-    const runs = snapshot.runs;
-    const lowerQuery = searchQuery?.toLowerCase() || "";
-    
-    return snapshot.projects.map(p => ({
-        ...p,
-        experiments: snapshot.experiments.filter(e => e.projectId === p.id).map(e => ({
-            ...e,
-            runs: runs.filter(r => r.experimentId === e.id).filter(r => 
-                !lowerQuery || r.name.toLowerCase().includes(lowerQuery) || r.id.includes(lowerQuery)
-            )
-        })).filter(e => e.runs.length > 0)
-    })).filter(p => p.experiments.length > 0);
-  }, [snapshot, searchQuery]);
-
-  // Auto-expand if searching
-  useEffect(() => {
-    if (searchQuery) {
-        const allIds = new Set<string>();
-        hierarchy.forEach(p => {
-             allIds.add(p.id);
-             p.experiments.forEach(e => allIds.add(e.id));
-        });
-        setExpandedIds(allIds);
-    }
-  }, [hierarchy, searchQuery]);
-
-  const toggleExpanded = (id: string) => {
-    setExpandedIds(prev => {
-        const next = new Set(prev);
-        if (next.has(id)) next.delete(id);
-        else next.add(id);
-        return next;
-    });
-  };
+const buildAssetNodes = (
+  snapshot: WorkspaceSnapshot,
+  onSelect: (selection: Selection) => void,
+  searchQuery: string,
+): TreeNode[] => {
+  return filterBySearch(snapshot.assets, searchQuery).map((asset) => ({
+    id: asset.id,
+    label: asset.name,
+    icon: Archive,
+    iconClassName: "text-amber-500",
+    right: <StatusBadge status={asset.status} size="sm" />,
+    onSelect: () => onSelect({ objectType: "asset", objectId: asset.id }),
+  }));
+};
 
-  if (hierarchy.length === 0) {
-      if (searchQuery) return <p className="text-xs text-muted-foreground px-4">No runs match "{searchQuery}".</p>;
-      return <p className="text-xs text-muted-foreground">No runs found.</p>;
-  }
+const buildWorkflowNodes = (
+  snapshot: WorkspaceSnapshot,
+  onSelect: (selection: Selection) => void,
+  searchQuery: string,
+): TreeNode[] => {
+  return filterBySearch(snapshot.workflows, searchQuery).map((workflow) => ({
+    id: workflow.id,
+    label: workflow.name,
+    icon: Workflow,
+    iconClassName: "text-sky-500",
+    right: <StatusBadge status={workflow.status} size="sm" />,
+    onSelect: () =>
+      onSelect({ objectType: "workflow", objectId: workflow.id, workflowId: workflow.id }),
+  }));
+};
 
-  return (
-    <div className="space-y-1">
-        {hierarchy.map(project => (
-            <div key={project.id} className="space-y-1">
-                {/* Project Node */}
-                <button
-                    type="button"
-                    className="flex w-full items-center gap-1 rounded-sm px-2 py-1 text-sm font-medium hover:bg-muted/40"
-                    onClick={() => toggleExpanded(project.id)}
-                >
-                    <ChevronRight className={`h-3.5 w-3.5 transition-transform ${expandedIds.has(project.id) ? "rotate-90" : ""}`} />
-                    <Folder className="mr-2 h-3.5 w-3.5 text-blue-500" />
-                    <span className="truncate flex-1 text-left min-w-0" title={project.name}>{project.name}</span>
-                    <span className="text-xs text-muted-foreground">{project.experiments.length}</span>
-                </button>
-
-                {expandedIds.has(project.id) && (
-                    <div className="pl-4 space-y-1">
-                        {project.experiments.map(exp => (
-                            <div key={exp.id} className="space-y-1">
-                                {/* Experiment Node */}
-                                <button
-                                    type="button"
-                                    className="flex w-full items-center gap-1 rounded-sm px-2 py-1 text-sm hover:bg-muted/40"
-                                    onClick={() => toggleExpanded(exp.id)}
-                                >
-                                     <ChevronRight className={`h-3.5 w-3.5 transition-transform ${expandedIds.has(exp.id) ? "rotate-90" : ""}`} />
-                                     <FlaskConical className="mr-2 h-3.5 w-3.5 text-purple-500" />
-                                     <span className="truncate flex-1 text-left min-w-0" title={exp.name}>{exp.name}</span>
-                                     <span className="text-xs text-muted-foreground">{exp.runs.length}</span>
-                                </button>
-
-                                {expandedIds.has(exp.id) && (
-                                    <div className="pl-6 space-y-1">
-                                        {exp.runs.map(run => (
-                                            <button
-                                                key={run.id}
-                                                type="button"
-                                                className={`flex w-full items-center gap-2 rounded-sm px-2 py-1 text-sm transition-colors overflow-hidden ${
-                                                    activeId === run.id ? "bg-accent text-accent-foreground" : "hover:bg-muted/40"
-                                                }`}
-                                                onClick={() => onSelect({ objectType: "run", objectId: run.id })}
-                                            >
-                                                <div className={`h-2 w-2 rounded-full flex-none ${
-                                                    run.status === 'succeeded' ? 'bg-green-500' :
-                                                    run.status === 'failed' ? 'bg-red-500' :
-                                                    run.status === 'running' ? 'bg-blue-500' : 'bg-gray-400'
-                                                }`} />
-                                                <span className="truncate flex-1 text-left min-w-0" title={run.name}>{run.name || run.id}</span>
-                                                <span className="text-[10px] text-muted-foreground font-mono flex-none">{run.id.substring(0,6)}</span>
-                                            </button>
-                                        ))}
-                                        {exp.runs.length === 0 && (
-                                            <p className="pl-6 text-xs text-muted-foreground py-1">No runs</p>
-                                        )}
-                                    </div>
-                                )}
-                            </div>
-                        ))}
-                         {project.experiments.length === 0 && (
-                             <p className="pl-6 text-xs text-muted-foreground py-1">No experiments</p>
-                        )}
-                    </div>
-                )}
-            </div>
-        ))}
-    </div>
-  );
+const buildAgentNodes = (
+  snapshot: WorkspaceSnapshot,
+  onSelect: (selection: Selection) => void,
+): TreeNode[] => {
+  return snapshot.agentSessions.map((session) => ({
+    id: session.id,
+    label: session.goalDescription,
+    icon: Bot,
+    iconClassName: "text-violet-500",
+    right: <StatusBadge status={session.status} size="sm" />,
+    meta: (
+      <span className="flex items-center gap-0.5">
+        <Clock className="h-2.5 w-2.5" />
+        {new Date(session.createdAt).toLocaleDateString()}
+      </span>
+    ),
+    onSelect: () => onSelect({ objectType: "agent", objectId: session.id }),
+  }));
 };
 
-const ExperimentTree = ({
-  snapshot,
-  onSelect,
-  activeId,
-  searchQuery,
-}: {
-  snapshot: WorkspaceSnapshot;
-  onSelect: (selection: Selection) => void;
-  activeId?: string;
-  searchQuery?: string;
-}): JSX.Element => {
-  const [expandedIds, setExpandedIds] = useState<Set<string>>(new Set());
-
-  const hierarchy = useMemo(() => {
-    const lowerQuery = searchQuery?.toLowerCase() || "";
-    
-    const projects = snapshot.projects.map(p => ({
-        ...p,
-        experiments: snapshot.experiments.filter(e => 
-            e.projectId === p.id && 
-            (!lowerQuery || e.name.toLowerCase().includes(lowerQuery) || e.summary?.toLowerCase().includes(lowerQuery))
-        )
-    })).filter(p => p.experiments.length > 0);
-    
-    return projects;
-  }, [snapshot, searchQuery]);
-
-  // Auto-expand if searching
-  useEffect(() => {
-    if (searchQuery) {
-        const allIds = new Set<string>();
-        hierarchy.forEach(p => allIds.add(p.id));
-        setExpandedIds(allIds);
+const buildProjectExpandPath = (
+  snapshot: WorkspaceSnapshot,
+  activeId: string | undefined,
+  searchQuery: string,
+): string[] => {
+  if (searchQuery) {
+    const ids: string[] = [];
+    for (const project of snapshot.projects) {
+      ids.push(project.id);
+      for (const experiment of snapshot.experiments.filter((e) => e.projectId === project.id)) {
+        ids.push(experiment.id);
+      }
     }
-  }, [hierarchy, searchQuery]);
-
-  const toggleExpanded = (id: string) => {
-    setExpandedIds(prev => {
-        const next = new Set(prev);
-        if (next.has(id)) next.delete(id);
-        else next.add(id);
-        return next;
-    });
-  };
-
-  if (hierarchy.length === 0) {
-      if (searchQuery) return <p className="text-xs text-muted-foreground px-4">No experiments match "{searchQuery}".</p>;
-      return <p className="text-xs text-muted-foreground">No experiments found.</p>;
+    return ids;
   }
 
-  return (
-    <div className="space-y-1">
-        {hierarchy.map(project => (
-            <div key={project.id} className="space-y-1">
-                {/* Project Node */}
-                <button
-                    type="button"
-                    className="flex w-full items-center gap-1 rounded-sm px-2 py-1 text-sm font-medium hover:bg-muted/40"
-                    onClick={() => toggleExpanded(project.id)}
-                >
-                    <ChevronRight className={`h-3.5 w-3.5 transition-transform ${expandedIds.has(project.id) ? "rotate-90" : ""}`} />
-                    <Folder className="mr-2 h-3.5 w-3.5 text-blue-500" />
-                    <span className="truncate flex-1 text-left min-w-0" title={project.name}>{project.name}</span>
-                    <span className="text-xs text-muted-foreground">{project.experiments.length}</span>
-                </button>
-
-                {expandedIds.has(project.id) && (
-                    <div className="pl-4 space-y-1">
-                        {project.experiments.map(exp => (
-                            <button
-                                key={exp.id}
-                                type="button"
-                                className={`flex w-full items-center gap-2 rounded-sm px-2 py-1 text-sm transition-colors overflow-hidden ${
-                                    activeId === exp.id ? "bg-accent text-accent-foreground" : "hover:bg-muted/40"
-                                }`}
-                                onClick={() => onSelect({ objectType: "experiment", objectId: exp.id })}
-                            >
-                                <FlaskConical className="h-3.5 w-3.5 text-purple-500 flex-none" />
-                                <span className="truncate flex-1 text-left min-w-0" title={exp.name}>{exp.name}</span>
-                                <Badge variant="secondary" className={`text-[10px] h-4 px-1 flex-none ${statusStyles[exp.status]}`}>
-                                    {exp.status}
-                                </Badge>
-                            </button>
-                        ))}
-                        {project.experiments.length === 0 && (
-                             <p className="pl-6 text-xs text-muted-foreground py-1">No experiments</p>
-                        )}
-                    </div>
-                )}
-            </div>
-        ))}
-    </div>
-  );
+  if (!activeId) return [];
+
+  const ids: string[] = [];
+  if (snapshot.projects.some((p) => p.id === activeId)) {
+    ids.push(activeId);
+  }
+  const experiment = snapshot.experiments.find((e) => e.id === activeId);
+  if (experiment) {
+    ids.push(experiment.projectId, experiment.id);
+  }
+  const run = snapshot.runs.find((r) => r.id === activeId);
+  if (run) {
+    ids.push(run.projectId, run.experimentId);
+  }
+  return ids;
 };
 
 export const LeftPanel = ({
@@ -560,96 +363,99 @@ export const LeftPanel = ({
   onRefresh,
   searchQuery = "",
 }: LeftPanelProps): JSX.Element => {
-  const listHeader = buildListHeader(view);
+  const listHeader = listHeaderByView[view];
   const hasWorkspace = Boolean(snapshot.workspaceRoot);
 
-  // Track previous selection to only sync on change
   const prevSelectionRef = useRef(selection);
-
-  // Sync view only when selection VALUE changes
   useEffect(() => {
     const prev = prevSelectionRef.current;
-    const isSameSelection = 
-        (prev === selection) || 
-        (prev?.objectId === selection?.objectId && prev?.objectType === selection?.objectType);
-
-    if (isSameSelection) return;
-    
+    const isSame =
+      prev === selection ||
+      (prev?.objectId === selection?.objectId && prev?.objectType === selection?.objectType);
+    if (isSame) return;
     prevSelectionRef.current = selection;
   }, [selection]);
 
   const activeId = selection ? selection.objectId : undefined;
-  const activePath = selection?.objectType === 'workspace-file' ? selection.filePath : undefined;
 
   const handleOpenWorkspace = (): void => {
     const path = window.prompt("Workspace path");
-    if (!path) {
-      return;
-    }
+    if (!path) return;
     onOpenWorkspace(path);
   };
-
   const handleCreateFile = (): void => {
     const path = window.prompt("New file path (relative to workspace)");
-    if (!path) {
-      return;
-    }
+    if (!path) return;
     onCreateFile(path);
   };
-
   const handleCreateDirectory = (): void => {
     const path = window.prompt("New folder path (relative to workspace)");
-    if (!path) {
-      return;
-    }
+    if (!path) return;
     onCreateDirectory(path);
   };
 
-  const filterItems = <T extends { name: string; summary?: string }>(items: T[]) => {
-    if (!searchQuery) return items;
-    const lowerQuery = searchQuery.toLowerCase();
-    return items.filter(item => 
-      item.name.toLowerCase().includes(lowerQuery) || 
-      item.summary?.toLowerCase().includes(lowerQuery)
-    );
-  };
+  const projectNodes = useMemo(
+    () => buildProjectNodes(snapshot, onSelect, searchQuery),
+    [snapshot, onSelect, searchQuery],
+  );
+  const workspaceNodes = useMemo(
+    () => buildWorkspaceNodes(snapshot, onSelect),
+    [snapshot, onSelect],
+  );
+  const assetNodes = useMemo(
+    () => buildAssetNodes(snapshot, onSelect, searchQuery),
+    [snapshot, onSelect, searchQuery],
+  );
+  const workflowNodes = useMemo(
+    () => buildWorkflowNodes(snapshot, onSelect, searchQuery),
+    [snapshot, onSelect, searchQuery],
+  );
+  const agentNodes = useMemo(() => buildAgentNodes(snapshot, onSelect), [snapshot, onSelect]);
 
-  const listContent: Record<LeftPanelView, JSX.Element> = {
-    workspace: <WorkspaceTree root={snapshot.workspaceRoot} onSelect={onSelect} activePath={activePath} snapshot={snapshot} />,
-    project: (
-      <div className="space-y-4">
-        <div className="flex justify-end px-1">
-          <CreateProjectDialog onProjectCreated={onRefresh} />
-        </div>
-        <SemanticList<ProjectSummary>
-          items={filterItems(snapshot.projects)}
-          onSelect={onSelect}
-          objectType="project"
-          activeId={activeId}
-        />
-      </div>
-    ),
-    experiment: (
-      <div className="space-y-6">
-         <ExperimentTree snapshot={snapshot} onSelect={onSelect} activeId={activeId} searchQuery={searchQuery} />
-      </div>
+  const projectExpandPath = useMemo(
+    () => buildProjectExpandPath(snapshot, activeId, searchQuery),
+    [snapshot, activeId, searchQuery],
+  );
+  const workspaceExpandPath = useMemo(
+    () => (snapshot.workspaceRoot ? [snapshot.workspaceRoot.id] : []),
+    [snapshot.workspaceRoot],
+  );
+
+  const treeByView: Record<LeftPanelView, JSX.Element> = {
+    projects: (
+      <TreeView
+        nodes={projectNodes}
+        activeId={activeId}
+        expandPath={projectExpandPath}
+        emptyTitle={searchQuery ? EMPTY_COPY.projectsFilter.title : EMPTY_COPY.entries.title}
+      />
     ),
-    run: (
-      <RunTree snapshot={snapshot} onSelect={onSelect} activeId={activeId} searchQuery={searchQuery} />
+    workspace: (
+      <TreeView
+        nodes={workspaceNodes}
+        activeId={activeId}
+        expandPath={workspaceExpandPath}
+        emptyTitle={EMPTY_COPY.workspace.title}
+      />
     ),
     asset: (
-      <SemanticList<AssetSummary>
-        items={filterItems(snapshot.assets)}
-        onSelect={onSelect}
-        objectType="asset"
+      <TreeView
+        nodes={assetNodes}
+        activeId={activeId}
+        emptyTitle={EMPTY_COPY.assets.title}
+        emptyDescription={EMPTY_COPY.assets.description}
       />
     ),
     workflow: (
-      <SemanticList<WorkflowSummary>
-        items={filterItems(snapshot.workflows)}
-        onSelect={onSelect}
-        objectType="workflow"
+      <TreeView nodes={workflowNodes} activeId={activeId} emptyTitle={EMPTY_COPY.entries.title} />
+    ),
+    agent: (
+      <TreeView
+        nodes={agentNodes}
         activeId={activeId}
+        emptyIcon={<Sparkles className="h-8 w-8" />}
+        emptyTitle={EMPTY_COPY.agentSessions.title}
+        emptyDescription={EMPTY_COPY.agentSessions.description}
       />
     ),
   };
@@ -658,7 +464,7 @@ export const LeftPanel = ({
     <div className="flex h-full">
       <TooltipProvider>
         <div className="flex w-14 flex-col items-center gap-2 border-r border-border bg-muted/20 py-4">
-          {viewOptions.map(option => {
+          {viewOptions.map((option) => {
             const isActive = view === option.id;
             return (
               <Tooltip key={option.id}>
@@ -666,9 +472,7 @@ export const LeftPanel = ({
                   <Button
                     variant={isActive ? "secondary" : "ghost"}
                     size="icon"
-                    onClick={() => {
-                      onViewChange(option.id);
-                    }}
+                    onClick={() => onViewChange(option.id)}
                   >
                     <option.icon className="h-4 w-4" />
                   </Button>
@@ -690,23 +494,30 @@ export const LeftPanel = ({
         </div>
       </TooltipProvider>
 
-      <div className="flex flex-1 flex-col min-w-0 overflow-hidden">
+      <div className="flex min-w-0 flex-1 flex-col overflow-hidden">
         <div className="space-y-1 px-4 py-3">
           <div className="flex items-center justify-between gap-2">
             <p className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">
               {listHeader}
             </p>
+
+            {view === "projects" && (
+              <div className="flex items-center gap-1">
+                <CreateProjectDialog onProjectCreated={onRefresh} />
+              </div>
+            )}
+
             {view === "workspace" && (
               <div className="flex items-center gap-1">
                 {!hasWorkspace ? (
                   <Button
-                    variant="outline"
-                    size="sm"
-                    className="h-7"
+                    variant="ghost"
+                    size="icon"
+                    className="h-7 w-7"
                     onClick={handleOpenWorkspace}
+                    aria-label="Open workspace"
                   >
-                    <FolderOpen className="mr-1 h-3.5 w-3.5" />
-                    Open
+                    <FolderOpen className="h-4 w-4" />
                   </Button>
                 ) : (
                   <>
@@ -741,10 +552,24 @@ export const LeftPanel = ({
                 )}
               </div>
             )}
+
+            {view === "agent" && (
+              <div className="flex items-center gap-1">
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="h-7 w-7"
+                  onClick={() => onSelect({ objectType: "agent", objectId: "new" })}
+                  aria-label="New goal"
+                >
+                  <Plus className="h-4 w-4" />
+                </Button>
+              </div>
+            )}
           </div>
           <Separator />
         </div>
-        <ScrollArea className="flex-1 px-4 pb-4">{listContent[view]}</ScrollArea>
+        <ScrollArea className="flex-1 px-4 pb-4">{treeByView[view]}</ScrollArea>
       </div>
     </div>
   );
diff --git a/ui/src/app/panels/RightPanel.tsx b/ui/src/app/panels/RightPanel.tsx
index f433771b..5a9a842e 100644
--- a/ui/src/app/panels/RightPanel.tsx
+++ b/ui/src/app/panels/RightPanel.tsx
@@ -1,12 +1,17 @@
-import { Card } from "@/components/ui/card";
-import { buildRendererKeyFromSelection, renderPlanByObjectType, resolveRenderer } from "@/app/registry";
+import {
+  buildRendererKeyFromSelection,
+  renderPlanByObjectType,
+  resolveRenderer,
+} from "@/app/registry";
 import type { InspectorTarget, Selection, WorkspaceSnapshot } from "@/app/types";
+import { Card } from "@/components/ui/card";
 
 interface RightPanelProps {
   selection: Selection | null;
   snapshot: WorkspaceSnapshot;
   inspectorTarget: InspectorTarget;
   onInspectorTargetChange: (target: InspectorTarget) => void;
+  onRefresh: () => void;
 }
 
 export const RightPanel = ({
@@ -14,6 +19,7 @@ export const RightPanel = ({
   snapshot,
   inspectorTarget,
   onInspectorTargetChange,
+  onRefresh,
 }: RightPanelProps): JSX.Element => {
   if (!selection) {
     return (
@@ -24,20 +30,21 @@ export const RightPanel = ({
   }
 
   const plan = renderPlanByObjectType[selection.objectType];
-  const renderers = plan.right.map(target => {
+  const renderers = plan.right.map((target) => {
     const key = buildRendererKeyFromSelection(selection, target);
-    return resolveRenderer(key);
+    return resolveRenderer(key, { selection, snapshot, target });
   });
 
   return (
-    <div className="flex h-full flex-col gap-4">
-      {renderers.map(renderer => (
+    <div className="flex h-full flex-col overflow-auto">
+      {renderers.map((renderer) => (
         <renderer.Component
           key={`${renderer.title}-${renderer.panelSlot}`}
           selection={selection}
           snapshot={snapshot}
           inspectorTarget={inspectorTarget}
           onInspectorTargetChange={onInspectorTargetChange}
+          onRefresh={onRefresh}
         />
       ))}
     </div>
diff --git a/ui/src/app/panels/TreeView.tsx b/ui/src/app/panels/TreeView.tsx
new file mode 100644
index 00000000..34e7d348
--- /dev/null
+++ b/ui/src/app/panels/TreeView.tsx
@@ -0,0 +1,171 @@
+import { ChevronRight } from "lucide-react";
+import type { ComponentType, JSX, ReactNode } from "react";
+import { useEffect, useState } from "react";
+import { EMPTY_COPY, EmptyState } from "@/app/components/entity";
+
+export interface TreeNode {
+  id: string;
+  label: string;
+  icon?: ComponentType<{ className?: string }>;
+  iconClassName?: string;
+  right?: ReactNode;
+  meta?: ReactNode;
+  children?: TreeNode[];
+  emptyChildLabel?: string;
+  onSelect?: () => void;
+}
+
+interface TreeViewProps {
+  nodes: TreeNode[];
+  activeId?: string;
+  expandPath?: string[];
+  emptyTitle?: string;
+  emptyDescription?: string;
+  emptyIcon?: ReactNode;
+}
+
+const INDENT = 14;
+
+interface RowProps {
+  node: TreeNode;
+  depth: number;
+  activeId?: string;
+  expanded: Set<string>;
+  onToggle: (id: string) => void;
+}
+
+const TreeRow = ({ node, depth, activeId, expanded, onToggle }: RowProps): JSX.Element => {
+  const hasChildren = node.children !== undefined;
+  const isExpanded = expanded.has(node.id);
+  const isActive = activeId === node.id;
+  const Icon = node.icon;
+
+  return (
+    <div>
+      <div className="flex items-center gap-0.5" style={{ paddingLeft: `${depth * INDENT}px` }}>
+        {hasChildren ? (
+          <button
+            type="button"
+            aria-label={isExpanded ? "Collapse" : "Expand"}
+            className="flex h-6 w-6 flex-none items-center justify-center rounded-sm text-muted-foreground transition-colors hover:bg-muted/40 hover:text-foreground"
+            onClick={(event) => {
+              event.stopPropagation();
+              onToggle(node.id);
+            }}
+          >
+            <ChevronRight
+              className={`h-3.5 w-3.5 transition-transform ${isExpanded ? "rotate-90" : ""}`}
+            />
+          </button>
+        ) : (
+          <span className="h-6 w-6 flex-none" />
+        )}
+        <button
+          type="button"
+          className={`group flex h-7 min-w-0 flex-1 items-center gap-2 overflow-hidden rounded-md px-2 text-left text-sm transition-colors ${
+            isActive ? "bg-accent text-accent-foreground" : "hover:bg-muted/40"
+          }`}
+          onClick={() => {
+            if (node.onSelect) {
+              node.onSelect();
+            } else if (hasChildren) {
+              onToggle(node.id);
+            }
+          }}
+          title={node.label}
+        >
+          {Icon && (
+            <Icon
+              className={`h-3.5 w-3.5 flex-none ${node.iconClassName ?? "text-muted-foreground"}`}
+            />
+          )}
+          <span className="min-w-0 flex-1 truncate">{node.label}</span>
+          {node.right && <span className="flex-none">{node.right}</span>}
+          {node.meta !== undefined && node.meta !== null && (
+            <span className="flex-none font-mono text-[10px] text-muted-foreground">
+              {node.meta}
+            </span>
+          )}
+        </button>
+      </div>
+      {node.children !== undefined && isExpanded && (
+        <div>
+          {node.children.length === 0 && node.emptyChildLabel ? (
+            <p
+              className="text-xs text-muted-foreground"
+              style={{ paddingLeft: `${(depth + 1) * INDENT + 8}px` }}
+            >
+              {node.emptyChildLabel}
+            </p>
+          ) : (
+            node.children.map((child) => (
+              <TreeRow
+                key={child.id}
+                node={child}
+                depth={depth + 1}
+                activeId={activeId}
+                expanded={expanded}
+                onToggle={onToggle}
+              />
+            ))
+          )}
+        </div>
+      )}
+    </div>
+  );
+};
+
+export const TreeView = ({
+  nodes,
+  activeId,
+  expandPath,
+  emptyTitle,
+  emptyDescription,
+  emptyIcon,
+}: TreeViewProps): JSX.Element => {
+  const [expanded, setExpanded] = useState<Set<string>>(() => new Set(expandPath ?? []));
+
+  useEffect(() => {
+    if (!expandPath || expandPath.length === 0) return;
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      for (const id of expandPath) next.add(id);
+      return next;
+    });
+  }, [expandPath]);
+
+  const toggle = (id: string): void => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  };
+
+  if (nodes.length === 0) {
+    return (
+      <EmptyState
+        title={emptyTitle ?? EMPTY_COPY.entries.title}
+        description={emptyDescription}
+        icon={emptyIcon}
+        density="compact"
+      />
+    );
+  }
+
+  return (
+    <div className="space-y-0.5">
+      {nodes.map((node) => (
+        <TreeRow
+          key={node.id}
+          node={node}
+          depth={0}
+          activeId={activeId}
+          expanded={expanded}
+          onToggle={toggle}
+        />
+      ))}
+    </div>
+  );
+};
diff --git a/ui/src/app/registry.test.ts b/ui/src/app/registry.test.ts
new file mode 100644
index 00000000..2c3fb91e
--- /dev/null
+++ b/ui/src/app/registry.test.ts
@@ -0,0 +1,283 @@
+/**
+ * Tests for app/registry.ts — renderer registry and key-building functions.
+ *
+ * Per project convention:
+ * - describe('functionName') wraps each exported function
+ * - it('...') covers one behaviour per case
+ * - registry is module-level state; clear it between tests
+ */
+
+import { beforeEach, describe, expect, it } from "@rstest/core";
+import type { RendererEntry } from "@/app/registry";
+import {
+  buildRegistryKey,
+  buildRendererKeyFromSelection,
+  registerRenderer,
+  registerRendererContribution,
+  renderPlanByObjectType,
+  resolveRenderer,
+} from "@/app/registry";
+import { resetUiPluginsForTests } from "@/plugins/runtime";
+import type { RendererKey, WorkspaceSnapshot } from "@/app/types";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeEntry(key: RendererKey, title = "Test"): RendererEntry {
+  return {
+    key,
+    title,
+    panelSlot: "center",
+    Component: (() => null) as unknown as RendererEntry["Component"],
+  };
+}
+
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  resetUiPluginsForTests();
+});
+
+describe("buildRegistryKey", () => {
+  it("joins all four parts with '::'", () => {
+    const key: RendererKey = {
+      objectType: "project",
+      fileKind: "json",
+      contentType: "metadata",
+      panelKind: "viewer",
+    };
+    expect(buildRegistryKey(key)).toBe("project::json::metadata::viewer");
+  });
+
+  it("produces consistent output for identical inputs", () => {
+    const key: RendererKey = {
+      objectType: "workflow",
+      fileKind: "yaml",
+      contentType: "workflow-graph",
+      panelKind: "inspector",
+    };
+    expect(buildRegistryKey(key)).toBe(buildRegistryKey(key));
+  });
+
+  it("distinguishes keys that differ only in one field", () => {
+    const base: RendererKey = {
+      objectType: "run",
+      fileKind: "json",
+      contentType: "metadata",
+      panelKind: "viewer",
+    };
+    const diffPanel: RendererKey = { ...base, panelKind: "inspector" };
+    expect(buildRegistryKey(base)).not.toBe(buildRegistryKey(diffPanel));
+  });
+});
+
+describe("registerRenderer", () => {
+  it("registers without throwing", () => {
+    const key: RendererKey = {
+      objectType: "asset",
+      fileKind: "json",
+      contentType: "metadata",
+      panelKind: "viewer",
+    };
+    expect(() => registerRenderer(makeEntry(key))).not.toThrow();
+  });
+
+  it("throws when the same key is registered twice", () => {
+    const key: RendererKey = {
+      objectType: "experiment",
+      fileKind: "json",
+      contentType: "metadata",
+      panelKind: "inspector",
+    };
+    registerRenderer(makeEntry(key, "First"));
+    expect(() => registerRenderer(makeEntry(key, "Second"))).toThrow(/already registered/);
+  });
+});
+
+describe("resolveRenderer", () => {
+  it("returns the registered entry", () => {
+    const key: RendererKey = {
+      objectType: "run",
+      fileKind: "json",
+      contentType: "log",
+      panelKind: "viewer",
+    };
+    const entry = makeEntry(key, "LogViewer");
+    registerRenderer(entry);
+    expect(resolveRenderer(key).title).toBe("LogViewer");
+  });
+
+  it("throws for an unregistered key", () => {
+    const key: RendererKey = {
+      objectType: "asset",
+      fileKind: "image",
+      contentType: "image",
+      panelKind: "inspector",
+    };
+    expect(() => resolveRenderer(key)).toThrow(/No renderer registered/);
+  });
+
+  it("prefers higher-priority contribution when runtime context matches", () => {
+    const key: RendererKey = {
+      objectType: "run",
+      fileKind: "json",
+      contentType: "metadata",
+      panelKind: "viewer",
+    };
+    registerRenderer(makeEntry(key, "Default"));
+    registerRendererContribution({
+      id: "molq:test-viewer",
+      key,
+      title: "Molq",
+      panelSlot: "center",
+      priority: 100,
+      matches: ({ selection, snapshot }) => {
+        const run = snapshot.runs.find((item) => item.id === selection.objectId);
+        return run?.executorInfo.backend === "molq";
+      },
+      Component: (() => null) as unknown as RendererEntry["Component"],
+    });
+
+    const snapshot = {
+      projects: [],
+      experiments: [],
+      runs: [
+        {
+          id: "run-1",
+          name: "run-1",
+          status: "running",
+          summary: "Status: running",
+          updatedAt: "2026-01-01T00:00:00Z",
+          projectId: "proj-1",
+          experimentId: "exp-1",
+          executorInfo: { backend: "molq" },
+        },
+      ],
+      assets: [],
+      workflows: [],
+      agentSessions: [],
+      workspaceRoot: null,
+      consoleEntries: [],
+    } satisfies WorkspaceSnapshot;
+
+    expect(
+      resolveRenderer(key, {
+        selection: { objectType: "run", objectId: "run-1" },
+        snapshot,
+        target: { panelKind: "viewer", contentType: "metadata", fileKind: "json" },
+      }).title,
+    ).toBe("Molq");
+  });
+});
+
+describe("renderPlanByObjectType", () => {
+  const types = ["project", "experiment", "run", "asset", "workflow", "workspace-file"] as const;
+
+  it("has an entry for every SemanticObjectType", () => {
+    for (const t of types) {
+      expect(renderPlanByObjectType).toHaveProperty(t);
+    }
+  });
+
+  it("each entry has non-empty center and right arrays", () => {
+    for (const t of types) {
+      expect(renderPlanByObjectType[t].center.length).toBeGreaterThan(0);
+      expect(renderPlanByObjectType[t].right.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("workflow uses yaml fileKind in center", () => {
+    const [centerTarget] = renderPlanByObjectType.workflow.center;
+    expect(centerTarget.fileKind).toBe("yaml");
+  });
+
+  it("workspace-file center uses editor panelKind", () => {
+    const [centerTarget] = renderPlanByObjectType["workspace-file"].center;
+    expect(centerTarget.panelKind).toBe("editor");
+  });
+});
+
+describe("buildRendererKeyFromSelection", () => {
+  it("uses target fileKind for non-workspace-file selection", () => {
+    const selection = { objectType: "project" as const, objectId: "proj-1" };
+    const target = {
+      panelKind: "viewer" as const,
+      contentType: "metadata" as const,
+      fileKind: "json" as const,
+    };
+    const result = buildRendererKeyFromSelection(selection, target);
+    expect(result.fileKind).toBe("json");
+    expect(result.objectType).toBe("project");
+  });
+
+  it("returns workflow-graph viewer key for workspace-file editor targeting workflow.json", () => {
+    const selection = {
+      objectType: "workspace-file" as const,
+      objectId: "/ws/workflow.json",
+      filePath: "/ws/workflow.json",
+      fileKind: "json" as const,
+    };
+    const target = {
+      panelKind: "editor" as const,
+      contentType: "text" as const,
+      fileKind: "text" as const,
+    };
+    const result = buildRendererKeyFromSelection(selection, target);
+    expect(result.contentType).toBe("workflow-graph");
+    expect(result.panelKind).toBe("viewer");
+    expect(result.fileKind).toBe("json");
+  });
+
+  it("returns image viewer key for workspace-file editor with image fileKind", () => {
+    const selection = {
+      objectType: "workspace-file" as const,
+      objectId: "/ws/photo.png",
+      filePath: "/ws/photo.png",
+      fileKind: "image" as const,
+    };
+    const target = {
+      panelKind: "editor" as const,
+      contentType: "text" as const,
+      fileKind: "text" as const,
+    };
+    const result = buildRendererKeyFromSelection(selection, target);
+    expect(result.contentType).toBe("image");
+    expect(result.panelKind).toBe("viewer");
+    expect(result.fileKind).toBe("image");
+  });
+
+  it("returns regular key for workspace-file non-editor target", () => {
+    const selection = {
+      objectType: "workspace-file" as const,
+      objectId: "/ws/notes.md",
+      filePath: "/ws/notes.md",
+      fileKind: "markdown" as const,
+    };
+    const target = {
+      panelKind: "inspector" as const,
+      contentType: "metadata" as const,
+      fileKind: "text" as const,
+    };
+    const result = buildRendererKeyFromSelection(selection, target);
+    expect(result.objectType).toBe("workspace-file");
+    expect(result.panelKind).toBe("inspector");
+    expect(result.fileKind).toBe("markdown");
+  });
+
+  it("uses selection fileKind (not target fileKind) for workspace-file", () => {
+    const selection = {
+      objectType: "workspace-file" as const,
+      objectId: "/ws/data.yaml",
+      filePath: "/ws/data.yaml",
+      fileKind: "yaml" as const,
+    };
+    const target = {
+      panelKind: "inspector" as const,
+      contentType: "metadata" as const,
+      fileKind: "text" as const,
+    };
+    const result = buildRendererKeyFromSelection(selection, target);
+    expect(result.fileKind).toBe("yaml");
+  });
+});
diff --git a/ui/src/app/registry.ts b/ui/src/app/registry.ts
index 648e1c6e..562b6434 100644
--- a/ui/src/app/registry.ts
+++ b/ui/src/app/registry.ts
@@ -1,56 +1,49 @@
+import type { RendererKey, Selection, SemanticObjectType } from "@/app/types";
+import {
+  registerRendererContribution as addRendererContribution,
+  resolveRendererContribution,
+} from "@/plugins/contribution-runtime";
 import type {
-  ContentType,
-  FileKind,
-  PanelKind,
-  RendererKey,
-  RendererProps,
-  SemanticObjectType,
-  Selection,
-} from "@/app/types";
+  RendererContribution,
+  RendererEntry,
+  RendererResolutionContext,
+  RenderTarget,
+} from "@/plugins/types";
+import { buildRendererRegistryKey } from "@/plugins/types";
 
-export type PanelSlot = "center" | "right";
+export type { PanelSlot, RendererContribution, RendererEntry, RenderTarget } from "@/plugins/types";
 
-export interface RendererEntry {
-  key: RendererKey;
-  title: string;
-  panelSlot: PanelSlot;
-  Component: (props: RendererProps) => JSX.Element;
+export interface RenderPlan {
+  center: RenderTarget[];
+  right: RenderTarget[];
 }
 
-const registry = new Map<string, RendererEntry>();
-
-export const buildRegistryKey = (key: RendererKey): string => {
-  return `${key.objectType}::${key.fileKind}::${key.contentType}::${key.panelKind}`;
-};
+export const buildRegistryKey = buildRendererRegistryKey;
 
 export const registerRenderer = (entry: RendererEntry): void => {
   const key = buildRegistryKey(entry.key);
-  if (registry.has(key)) {
-    throw new Error(`Renderer already registered for ${key}`);
-  }
-  registry.set(key, entry);
+  addRendererContribution({
+    id: `exact:${key}`,
+    ...entry,
+  });
+};
+
+export const registerRendererContribution = (entry: RendererContribution): void => {
+  addRendererContribution(entry);
 };
 
-export const resolveRenderer = (key: RendererKey): RendererEntry => {
+export const resolveRenderer = (
+  key: RendererKey,
+  context?: Omit<RendererResolutionContext, "key">,
+): RendererEntry => {
   const registryKey = buildRegistryKey(key);
-  const entry = registry.get(registryKey);
+  const entry = resolveRendererContribution(key, context);
   if (!entry) {
     throw new Error(`No renderer registered for ${registryKey}`);
   }
   return entry;
 };
 
-export interface RenderTarget {
-  panelKind: PanelKind;
-  contentType: ContentType;
-  fileKind: FileKind;
-}
-
-export interface RenderPlan {
-  center: RenderTarget[];
-  right: RenderTarget[];
-}
-
 export const renderPlanByObjectType: Record<SemanticObjectType, RenderPlan> = {
   project: {
     center: [{ panelKind: "viewer", contentType: "metadata", fileKind: "json" }],
@@ -76,6 +69,10 @@ export const renderPlanByObjectType: Record<SemanticObjectType, RenderPlan> = {
     center: [{ panelKind: "editor", contentType: "text", fileKind: "text" }],
     right: [{ panelKind: "inspector", contentType: "metadata", fileKind: "text" }],
   },
+  agent: {
+    center: [{ panelKind: "viewer", contentType: "metadata", fileKind: "json" }],
+    right: [{ panelKind: "inspector", contentType: "metadata", fileKind: "json" }],
+  },
 };
 
 export const buildRendererKeyFromSelection = (
diff --git a/ui/src/app/renderers/AgentViewer.tsx b/ui/src/app/renderers/AgentViewer.tsx
new file mode 100644
index 00000000..0276cc32
--- /dev/null
+++ b/ui/src/app/renderers/AgentViewer.tsx
@@ -0,0 +1,500 @@
+import {
+  Bot,
+  CheckCircle2,
+  ChevronDown,
+  ChevronRight,
+  Loader2,
+  Play,
+  RotateCcw,
+  Send,
+  ShieldAlert,
+  Sparkles,
+  Terminal,
+  Workflow,
+  XCircle,
+} from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { EmptyState, EntityHeader, EntityMetric, StatusBadge } from "@/app/components/entity";
+import { agentApi } from "@/app/state/api";
+import { useNavigationState } from "@/app/state/useNavigationState";
+import type {
+  ApiAgentSession,
+  ApiSessionEvent,
+  RendererProps,
+  WorkspaceSnapshot,
+} from "@/app/types";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Separator } from "@/components/ui/separator";
+
+// ---------------------------------------------------------------------------
+// Event row
+// ---------------------------------------------------------------------------
+
+const EVENT_META: Record<string, { icon: typeof Bot; label: string; colorClass: string }> = {
+  PlanCreatedEvent: { icon: Sparkles, label: "Plan created", colorClass: "text-violet-500" },
+  ToolCallEvent: { icon: Terminal, label: "Tool call", colorClass: "text-blue-500" },
+  ToolResultEvent: { icon: CheckCircle2, label: "Tool result", colorClass: "text-green-600" },
+  WorkflowStartedEvent: { icon: Workflow, label: "Workflow started", colorClass: "text-sky-500" },
+  ObservationEvent: { icon: Bot, label: "Observation", colorClass: "text-muted-foreground" },
+  ReplanEvent: { icon: RotateCcw, label: "Replanning", colorClass: "text-amber-500" },
+  ApprovalRequestEvent: {
+    icon: ShieldAlert,
+    label: "Approval needed",
+    colorClass: "text-orange-500",
+  },
+  SessionCompletedEvent: { icon: CheckCircle2, label: "Completed", colorClass: "text-emerald-500" },
+};
+
+const formatTs = (ts: string): string => {
+  try {
+    return new Date(ts).toLocaleTimeString([], {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+    });
+  } catch {
+    return ts;
+  }
+};
+
+const EventRow = ({
+  event,
+  sessionId: _sessionId,
+  onApprovalRespond,
+}: {
+  event: ApiSessionEvent;
+  sessionId: string;
+  onApprovalRespond: (requestId: string, approved: boolean) => void;
+}): JSX.Element => {
+  const [expanded, setExpanded] = useState(false);
+  const meta = EVENT_META[event.type] ?? {
+    icon: Bot,
+    label: event.type,
+    colorClass: "text-muted-foreground",
+  };
+  const Icon = meta.icon;
+  const hasDetail = Object.keys(event.payload).length > 0;
+
+  return (
+    <div className="group flex gap-3 py-2">
+      <div className={`mt-0.5 flex-none ${meta.colorClass}`}>
+        <Icon className="h-4 w-4" />
+      </div>
+      <div className="min-w-0 flex-1 space-y-1">
+        <div className="flex items-center gap-2">
+          <span className="text-sm font-medium">{meta.label}</span>
+          {event.type === "ToolCallEvent" && event.payload.tool_name && (
+            <Badge variant="secondary" className="font-mono text-[10px] h-4 px-1">
+              {String(event.payload.tool_name)}
+            </Badge>
+          )}
+          {event.type === "WorkflowStartedEvent" && event.payload.run_id && (
+            <Badge variant="secondary" className="font-mono text-[10px] h-4 px-1">
+              {String(event.payload.run_id)}
+            </Badge>
+          )}
+          <span className="ml-auto text-[10px] text-muted-foreground tabular-nums">
+            {formatTs(event.ts)}
+          </span>
+          {hasDetail && (
+            <button
+              type="button"
+              className="text-muted-foreground hover:text-foreground transition-colors"
+              onClick={() => setExpanded((v) => !v)}
+              aria-label={expanded ? "Collapse" : "Expand"}
+            >
+              {expanded ? (
+                <ChevronDown className="h-3 w-3" />
+              ) : (
+                <ChevronRight className="h-3 w-3" />
+              )}
+            </button>
+          )}
+        </div>
+
+        {/* Inline content for common event types */}
+        {event.type === "PlanCreatedEvent" && Array.isArray(event.payload.plan_steps) && (
+          <ol className="ml-2 space-y-0.5">
+            {(event.payload.plan_steps as string[]).map((step, stepNum) => (
+              <li
+                key={`plan-step-${step.slice(0, 40)}`}
+                className="flex gap-2 text-xs text-muted-foreground"
+              >
+                <span className="font-mono text-primary/60">{stepNum + 1}.</span>
+                <span>{step}</span>
+              </li>
+            ))}
+          </ol>
+        )}
+
+        {event.type === "ObservationEvent" && event.payload.content && (
+          <p className="text-xs text-muted-foreground">{String(event.payload.content)}</p>
+        )}
+
+        {event.type === "ReplanEvent" && (
+          <div className="rounded-md border border-amber-200 bg-amber-50 px-3 py-2 dark:border-amber-800 dark:bg-amber-950/30">
+            {event.payload.reason && (
+              <p className="text-xs text-amber-700 dark:text-amber-400">
+                {String(event.payload.reason)}
+              </p>
+            )}
+            {Array.isArray(event.payload.new_plan) &&
+              (event.payload.new_plan as string[]).map((step, stepNum) => (
+                <p
+                  key={`replan-step-${step.slice(0, 40)}`}
+                  className="text-xs text-amber-700 dark:text-amber-400"
+                >
+                  {stepNum + 1}. {step}
+                </p>
+              ))}
+          </div>
+        )}
+
+        {event.type === "SessionCompletedEvent" && (
+          <div className="rounded-md border border-emerald-200 bg-emerald-50 px-3 py-2 dark:border-emerald-800 dark:bg-emerald-950/30">
+            {event.payload.summary && (
+              <p className="text-xs text-emerald-700 dark:text-emerald-400">
+                {String(event.payload.summary)}
+              </p>
+            )}
+          </div>
+        )}
+
+        {event.type === "ApprovalRequestEvent" && event.payload.request_id && (
+          <div className="flex items-center gap-2 rounded-md border border-orange-200 bg-orange-50 px-3 py-2 dark:border-orange-800 dark:bg-orange-950/30">
+            <p className="flex-1 text-xs text-orange-700 dark:text-orange-400">
+              Approve{" "}
+              <span className="font-mono font-semibold">
+                {String(event.payload.tool_name ?? "action")}
+              </span>
+              ?
+            </p>
+            <Button
+              size="sm"
+              variant="outline"
+              className="h-6 border-orange-400 text-orange-700 hover:bg-orange-100"
+              onClick={() => onApprovalRespond(String(event.payload.request_id), false)}
+            >
+              Deny
+            </Button>
+            <Button
+              size="sm"
+              className="h-6 bg-orange-500 text-white hover:bg-orange-600"
+              onClick={() => onApprovalRespond(String(event.payload.request_id), true)}
+            >
+              Approve
+            </Button>
+          </div>
+        )}
+
+        {expanded && hasDetail && (
+          <pre className="overflow-x-auto rounded-md bg-muted/60 px-3 py-2 text-[11px] font-mono text-muted-foreground">
+            {JSON.stringify(event.payload, null, 2)}
+          </pre>
+        )}
+      </div>
+    </div>
+  );
+};
+
+// ---------------------------------------------------------------------------
+// Goal input form
+// ---------------------------------------------------------------------------
+
+const GoalInput = ({
+  onSubmit,
+  disabled,
+}: {
+  onSubmit: (description: string, criteria: string[]) => void;
+  disabled: boolean;
+}): JSX.Element => {
+  const [description, setDescription] = useState("");
+  const [criteriaText, setCriteriaText] = useState("");
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+
+  const handleSubmit = (): void => {
+    const trimmed = description.trim();
+    if (!trimmed) return;
+    const criteria = criteriaText
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean);
+    onSubmit(trimmed, criteria);
+    setDescription("");
+    setCriteriaText("");
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent): void => {
+    if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
+      e.preventDefault();
+      handleSubmit();
+    }
+  };
+
+  return (
+    <div className="space-y-3 rounded-xl border border-border bg-card p-4">
+      <div className="flex items-center gap-2 text-sm font-semibold">
+        <Sparkles className="h-4 w-4 text-violet-500" />
+        New Goal
+      </div>
+      <textarea
+        ref={textareaRef}
+        className="w-full resize-none rounded-lg border border-input bg-background px-3 py-2 text-sm placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring"
+        rows={3}
+        placeholder="Describe your goal... (⌘+Enter to submit)"
+        value={description}
+        onChange={(e) => setDescription(e.target.value)}
+        onKeyDown={handleKeyDown}
+        disabled={disabled}
+      />
+      <textarea
+        className="w-full resize-none rounded-lg border border-input bg-background px-3 py-2 text-sm placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring"
+        rows={2}
+        placeholder="Success criteria (one per line, optional)"
+        value={criteriaText}
+        onChange={(e) => setCriteriaText(e.target.value)}
+        disabled={disabled}
+      />
+      <div className="flex justify-end">
+        <Button disabled={disabled || !description.trim()} onClick={handleSubmit} className="gap-2">
+          {disabled ? <Loader2 className="h-4 w-4 animate-spin" /> : <Send className="h-4 w-4" />}
+          {disabled ? "Submitting..." : "Start Session"}
+        </Button>
+      </div>
+    </div>
+  );
+};
+
+// ---------------------------------------------------------------------------
+// Session header
+// ---------------------------------------------------------------------------
+
+const SessionHeader = ({
+  session,
+  eventCount,
+  snapshot,
+}: {
+  session: ApiAgentSession;
+  eventCount: number;
+  snapshot: WorkspaceSnapshot;
+}): JSX.Element => {
+  const toolCallCount = session.events.filter((event) => event.type === "ToolCallEvent").length;
+  const { breadcrumbs, canNavigateUp, navigateUp } = useNavigationState(snapshot);
+  return (
+    <EntityHeader
+      breadcrumbs={breadcrumbs}
+      canNavigateUp={canNavigateUp}
+      onNavigateUp={navigateUp}
+      icon={Bot}
+      title={session.goalDescription}
+      status={session.status}
+      metrics={
+        <>
+          <EntityMetric label="Events" value={eventCount} />
+          <EntityMetric label="Tool Calls" value={toolCallCount} />
+        </>
+      }
+    />
+  );
+};
+
+// ---------------------------------------------------------------------------
+// Main AgentViewer
+// ---------------------------------------------------------------------------
+
+export const AgentViewer = ({
+  selection,
+  snapshot,
+  onRefresh,
+}: RendererProps): JSX.Element | null => {
+  const sessionId = selection.objectId === "new" ? null : selection.objectId;
+  const [session, setSession] = useState<ApiAgentSession | null>(null);
+  const [events, setEvents] = useState<ApiSessionEvent[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [submitting, setSubmitting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const scrollRef = useRef<HTMLDivElement>(null);
+  const esRef = useRef<EventSource | null>(null);
+
+  // Load session when sessionId changes
+  useEffect(() => {
+    if (!sessionId) {
+      setSession(null);
+      setEvents([]);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    agentApi
+      .getSession(sessionId)
+      .then((s) => {
+        setSession(s);
+        setEvents(s.events);
+      })
+      .catch((err) => setError(String(err)))
+      .finally(() => setLoading(false));
+  }, [sessionId]);
+
+  // SSE stream for running sessions
+  useEffect(() => {
+    if (!session || session.status !== "running") return;
+    const es = agentApi.streamEvents(session.sessionId);
+    esRef.current = es;
+    es.onmessage = (e) => {
+      try {
+        const data = JSON.parse(e.data);
+        if (data.type === "done") {
+          es.close();
+          agentApi.getSession(session.sessionId).then((s) => {
+            setSession(s);
+            setEvents(s.events);
+          });
+          return;
+        }
+        if (data.type !== "waiting") {
+          setEvents((prev) => [...prev, data as ApiSessionEvent]);
+        }
+      } catch {
+        // ignore parse errors
+      }
+    };
+    return () => {
+      es.close();
+    };
+  }, [session?.sessionId, session?.status, session]);
+
+  // Auto-scroll to bottom when events change
+  useEffect(() => {
+    if (scrollRef.current) {
+      scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
+    }
+  }, []);
+
+  const handleGoalSubmit = useCallback(
+    async (description: string, criteria: string[]) => {
+      setSubmitting(true);
+      setError(null);
+      try {
+        const created = await agentApi.createSession(description, criteria);
+        setSession(created);
+        setEvents(created.events);
+        onRefresh();
+      } catch (err) {
+        setError(String(err));
+      } finally {
+        setSubmitting(false);
+      }
+    },
+    [onRefresh],
+  );
+
+  const handleApprovalRespond = useCallback(
+    async (requestId: string, approved: boolean) => {
+      if (!session) return;
+      try {
+        await agentApi.respondApproval(session.sessionId, requestId, approved);
+      } catch (err) {
+        setError(String(err));
+      }
+    },
+    [session],
+  );
+
+  // --- "new" state: show goal input ---
+  if (!sessionId || (!loading && !session)) {
+    return (
+      <div className="flex h-full flex-col gap-4 overflow-auto p-4">
+        <GoalInput onSubmit={handleGoalSubmit} disabled={submitting} />
+        {error && (
+          <div className="rounded-md border border-red-200 bg-red-50 px-4 py-2 text-sm text-red-700 dark:border-red-800 dark:bg-red-950/30 dark:text-red-400">
+            {error}
+          </div>
+        )}
+        {snapshot.agentSessions.length > 0 && (
+          <div className="space-y-1">
+            <p className="px-1 text-xs font-semibold uppercase tracking-wide text-muted-foreground">
+              Recent sessions
+            </p>
+            {snapshot.agentSessions.slice(0, 5).map((s) => (
+              <div
+                key={s.id}
+                className="flex items-center gap-3 rounded-lg border border-border/60 bg-background px-3 py-2 text-left hover:bg-muted/40"
+              >
+                <Bot className="h-4 w-4 flex-none text-violet-400" />
+                <p className="flex-1 truncate text-sm">{s.goalDescription}</p>
+                <StatusBadge status={s.status} size="sm" />
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+    );
+  }
+
+  if (loading) {
+    return (
+      <div className="flex h-full items-center justify-center">
+        <Loader2 className="h-6 w-6 animate-spin text-muted-foreground" />
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className="flex h-full flex-col items-center justify-center gap-3 p-8 text-center">
+        <XCircle className="h-10 w-10 text-red-500" />
+        <p className="text-sm text-muted-foreground">{error}</p>
+        <Button variant="outline" size="sm" onClick={() => setError(null)}>
+          Retry
+        </Button>
+      </div>
+    );
+  }
+
+  if (!session) return null;
+
+  return (
+    <div className="flex h-full flex-col bg-background">
+      <SessionHeader session={session} eventCount={events.length} snapshot={snapshot} />
+
+      <div className="flex items-center gap-2 border-b border-border/70 bg-muted/10 px-6 py-2 md:px-8">
+        <p className="flex-1 text-xs font-semibold uppercase tracking-wide text-muted-foreground">
+          Event stream
+        </p>
+        {session.status === "running" && (
+          <span className="flex items-center gap-1 text-xs text-blue-500">
+            <Loader2 className="h-3 w-3 animate-spin" />
+            Live
+          </span>
+        )}
+      </div>
+
+      <ScrollArea className="flex-1" ref={scrollRef as React.RefObject<HTMLDivElement>}>
+        {events.length === 0 ? (
+          <EmptyState title="Waiting for events…" icon={<Play className="h-8 w-8" />} />
+        ) : (
+          <div className="space-y-1 px-6 pb-4 pr-6 md:px-8">
+            {events.map((event, eventIdx) => (
+              <div key={`event-${event.type}-${event.ts}`}>
+                <EventRow
+                  event={event}
+                  sessionId={session.sessionId}
+                  onApprovalRespond={handleApprovalRespond}
+                />
+                {eventIdx < events.length - 1 && <Separator className="opacity-30" />}
+              </div>
+            ))}
+          </div>
+        )}
+      </ScrollArea>
+
+      {session.status === "completed" && (
+        <div className="border-t border-border/70 p-4">
+          <GoalInput onSubmit={handleGoalSubmit} disabled={submitting} />
+        </div>
+      )}
+    </div>
+  );
+};
diff --git a/ui/src/app/renderers/AssetViewer.tsx b/ui/src/app/renderers/AssetViewer.tsx
new file mode 100644
index 00000000..dc6d8c0c
--- /dev/null
+++ b/ui/src/app/renderers/AssetViewer.tsx
@@ -0,0 +1,378 @@
+import { Archive, Download, FileText, Image as ImageIcon, Package } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import type { DataTableColumn } from "@/app/components/entity";
+import {
+  DataTable,
+  EMPTY_COPY,
+  EmptyState,
+  EntityHeader,
+  EntityMetric,
+  KeyValueGrid,
+} from "@/app/components/entity";
+import { workspaceApi } from "@/app/state/api";
+import { useNavigationState } from "@/app/state/useNavigationState";
+import type { ApiAssetFile, ApiAssetResponse, RendererProps } from "@/app/types";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+
+const formatBytes = (bytes: number): string => {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+};
+
+const isTextual = (mime: string | undefined, format: string): boolean => {
+  if (mime?.startsWith("text/")) return true;
+  return ["json", "yaml", "yml", "txt", "md", "markdown", "py", "csv"].includes(
+    format.toLowerCase(),
+  );
+};
+
+const isImage = (mime: string | undefined, format: string): boolean => {
+  if (mime?.startsWith("image/")) return true;
+  return ["png", "jpg", "jpeg", "gif", "webp", "svg"].includes(format.toLowerCase());
+};
+
+const ContentPreview = ({ asset }: { asset: ApiAssetResponse }): JSX.Element => {
+  const [textContent, setTextContent] = useState<string | null>(null);
+  const [imageUrl, setImageUrl] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const textual = isTextual(asset.mimeType, asset.format);
+  const image = isImage(asset.mimeType, asset.format);
+
+  useEffect(() => {
+    if (!textual && !image) return;
+
+    let cancelled = false;
+    let objectUrl: string | null = null;
+
+    fetch(`/api/assets/${encodeURIComponent(asset.assetId)}/download`)
+      .then((response) => {
+        if (!response.ok) {
+          throw new Error(`Failed to load asset: ${response.statusText}`);
+        }
+        return response.blob();
+      })
+      .then((blob) => {
+        if (cancelled) return;
+        if (image) {
+          objectUrl = URL.createObjectURL(blob);
+          setImageUrl(objectUrl);
+        } else if (textual) {
+          return blob.text().then((text) => {
+            if (cancelled) return;
+            setTextContent(text);
+          });
+        }
+      })
+      .catch((err) => {
+        if (!cancelled) {
+          setError(err instanceof Error ? err.message : "Failed to load asset content");
+        }
+      });
+
+    return () => {
+      cancelled = true;
+      if (objectUrl) URL.revokeObjectURL(objectUrl);
+    };
+  }, [asset.assetId, textual, image]);
+
+  const downloadUrl = `/api/assets/${encodeURIComponent(asset.assetId)}/download`;
+
+  if (error) {
+    return (
+      <div className="p-6">
+        <EmptyState title="Failed to load content." description={error} />
+      </div>
+    );
+  }
+
+  if (image) {
+    return (
+      <div className="flex h-full items-center justify-center bg-muted/20 p-6">
+        {imageUrl ? (
+          <img
+            src={imageUrl}
+            alt={asset.assetId}
+            className="max-h-full max-w-full rounded-md border border-border/60"
+          />
+        ) : (
+          <EmptyState title="Loading…" icon={<ImageIcon className="h-8 w-8" />} />
+        )}
+      </div>
+    );
+  }
+
+  if (textual) {
+    let displayed = textContent ?? "";
+    if (textContent && asset.format.toLowerCase() === "json") {
+      try {
+        displayed = JSON.stringify(JSON.parse(textContent), null, 2);
+      } catch {
+        // leave as-is
+      }
+    }
+    return (
+      <div className="h-full overflow-auto">
+        <pre className="whitespace-pre-wrap break-words px-6 py-4 font-mono text-xs text-foreground">
+          {textContent === null ? "Loading…" : displayed}
+        </pre>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex h-full items-center justify-center">
+      <EmptyState
+        title="Binary content"
+        description={`${formatBytes(asset.size)} · ${asset.format}`}
+        icon={<Package className="h-8 w-8" />}
+        action={
+          <a href={downloadUrl} download={`${asset.assetId}.${asset.format}`}>
+            <Button size="sm" variant="outline">
+              <Download className="mr-2 h-4 w-4" />
+              Download
+            </Button>
+          </a>
+        }
+      />
+    </div>
+  );
+};
+
+export const AssetViewer = ({ selection, snapshot }: RendererProps): JSX.Element => {
+  const [asset, setAsset] = useState<ApiAssetResponse | null>(null);
+  const [notFound, setNotFound] = useState(false);
+  const { setSelection, breadcrumbs, canNavigateUp, navigateUp } = useNavigationState(snapshot);
+
+  const assetId = selection.objectId;
+
+  useEffect(() => {
+    let cancelled = false;
+    workspaceApi
+      .getAssets()
+      .then((all) => {
+        if (cancelled) return;
+        const match = all.find((a) => a.id === assetId || a.assetId === assetId);
+        if (!match) {
+          setNotFound(true);
+        } else {
+          setAsset(match);
+          setNotFound(false);
+        }
+      })
+      .catch((err) => {
+        console.error("Failed to load asset", err);
+        setNotFound(true);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [assetId]);
+
+  const assetSummary = useMemo(
+    () => snapshot.assets.find((a) => a.id === assetId),
+    [snapshot.assets, assetId],
+  );
+
+  if (notFound) {
+    return <div className="p-8 text-muted-foreground">Asset not found.</div>;
+  }
+
+  if (!asset) {
+    return <div className="p-8 text-muted-foreground">Loading asset…</div>;
+  }
+
+  const fileColumns: DataTableColumn<ApiAssetFile>[] = [
+    {
+      key: "path",
+      header: "Path",
+      cell: (file) => (
+        <div className="flex items-center gap-2">
+          <FileText className="h-4 w-4 text-muted-foreground" />
+          <span className="font-mono text-xs text-foreground">{file.path}</span>
+        </div>
+      ),
+    },
+    {
+      key: "size",
+      header: "Size",
+      width: "w-[120px]",
+      cell: (file) => <span className="font-mono text-xs">{formatBytes(file.size)}</span>,
+    },
+    {
+      key: "hash",
+      header: "Hash",
+      cell: (file) => (
+        <span
+          className="block max-w-[360px] truncate font-mono text-xs text-muted-foreground"
+          title={file.hash}
+        >
+          {file.hash}
+        </span>
+      ),
+    },
+  ];
+
+  const downloadUrl = `/api/assets/${encodeURIComponent(asset.assetId)}/download`;
+
+  const producerRun = asset.producerRunId
+    ? snapshot.runs.find((r) => r.id === asset.producerRunId)
+    : null;
+
+  return (
+    <div className="flex h-full flex-col bg-background">
+      <EntityHeader
+        breadcrumbs={breadcrumbs}
+        canNavigateUp={canNavigateUp}
+        onNavigateUp={navigateUp}
+        icon={Archive}
+        title={asset.assetId}
+        status={assetSummary?.status}
+        subtitle={assetSummary?.summary || undefined}
+        actions={
+          <a href={downloadUrl} download={`${asset.assetId}.${asset.format}`}>
+            <Button variant="outline" size="sm">
+              <Download className="mr-2 h-4 w-4" />
+              Download
+            </Button>
+          </a>
+        }
+        metrics={
+          <>
+            <EntityMetric label="Files" value={asset.files?.length ?? 0} />
+            <EntityMetric label="Size" value={formatBytes(asset.size)} />
+          </>
+        }
+      />
+
+      <div className="flex flex-1 flex-col overflow-hidden">
+        <Tabs defaultValue="overview" className="flex flex-1 flex-col">
+          <div className="border-b border-border/70 bg-muted/10 px-6 py-2 md:px-8">
+            <TabsList className="h-auto w-fit justify-start rounded-md bg-transparent p-0">
+              <TabsTrigger value="overview" className="rounded-md px-4 py-2 text-sm font-medium">
+                Overview
+              </TabsTrigger>
+              <TabsTrigger value="content" className="rounded-md px-4 py-2 text-sm font-medium">
+                Content
+              </TabsTrigger>
+              <TabsTrigger value="files" className="rounded-md px-4 py-2 text-sm font-medium">
+                Files
+              </TabsTrigger>
+            </TabsList>
+          </div>
+
+          <TabsContent
+            value="overview"
+            className="m-0 flex flex-1 flex-col overflow-auto p-6 md:p-8"
+          >
+            <div className="max-w-3xl space-y-6">
+              {(assetSummary?.projectId || producerRun) && (
+                <div>
+                  <h3 className="text-sm font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+                    Relationships
+                  </h3>
+                  <div className="mt-3 flex flex-wrap gap-2">
+                    {assetSummary?.projectId && (
+                      <Button
+                        variant="outline"
+                        size="sm"
+                        onClick={() => {
+                          if (assetSummary.projectId) {
+                            setSelection({
+                              objectType: "project",
+                              objectId: assetSummary.projectId,
+                            });
+                          }
+                        }}
+                      >
+                        Project: {assetSummary.projectId}
+                      </Button>
+                    )}
+                    {producerRun && (
+                      <Button
+                        variant="outline"
+                        size="sm"
+                        onClick={() =>
+                          setSelection({ objectType: "run", objectId: producerRun.id })
+                        }
+                      >
+                        Producer Run: {producerRun.name || producerRun.id}
+                      </Button>
+                    )}
+                  </div>
+                </div>
+              )}
+
+              <div>
+                <h3 className="text-sm font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+                  Metadata
+                </h3>
+                <div className="mt-4">
+                  <KeyValueGrid
+                    items={[
+                      {
+                        label: "Asset ID",
+                        value: <span className="font-mono text-xs">{asset.assetId}</span>,
+                      },
+                      {
+                        label: "Internal ID",
+                        value: <span className="font-mono text-xs">{asset.id}</span>,
+                      },
+                      { label: "Type", value: asset.type },
+                      { label: "Format", value: asset.format },
+                      { label: "MIME Type", value: asset.mimeType || "-" },
+                      { label: "Size", value: formatBytes(asset.size) },
+                      {
+                        label: "Content Hash",
+                        value: (
+                          <span className="break-all font-mono text-xs">{asset.contentHash}</span>
+                        ),
+                      },
+                      { label: "Created", value: new Date(asset.created).toLocaleString() },
+                    ]}
+                  />
+                </div>
+              </div>
+
+              {asset.tags && asset.tags.length > 0 && (
+                <div>
+                  <h3 className="text-sm font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+                    Tags
+                  </h3>
+                  <div className="mt-3 flex flex-wrap gap-1.5">
+                    {asset.tags.map((tag) => (
+                      <Badge key={tag} variant="secondary" className="text-xs">
+                        {tag}
+                      </Badge>
+                    ))}
+                  </div>
+                </div>
+              )}
+            </div>
+          </TabsContent>
+
+          <TabsContent value="content" className="m-0 flex flex-1 flex-col overflow-hidden p-0">
+            <ContentPreview asset={asset} />
+          </TabsContent>
+
+          <TabsContent value="files" className="m-0 flex flex-1 flex-col overflow-hidden p-0">
+            <DataTable
+              columns={fileColumns}
+              data={asset.files ?? []}
+              getRowKey={(file) => file.path}
+              empty={
+                <EmptyState
+                  title={EMPTY_COPY.assets.title}
+                  description="This asset has no file manifest."
+                />
+              }
+            />
+          </TabsContent>
+        </Tabs>
+      </div>
+    </div>
+  );
+};
diff --git a/ui/src/app/renderers/ExperimentViewer.tsx b/ui/src/app/renderers/ExperimentViewer.tsx
index 9f4310f0..ae0b4de7 100644
--- a/ui/src/app/renderers/ExperimentViewer.tsx
+++ b/ui/src/app/renderers/ExperimentViewer.tsx
@@ -1,68 +1,49 @@
-
-
-import { Clock, FlaskConical, Play, Trash2, Activity, CheckCircle2, XCircle } from "lucide-react";
+import { FileQuestion, FlaskConical, Play, Trash2 } from "lucide-react";
 import { useMemo, useState } from "react";
-import { Button } from "@/components/ui/button";
-import { Badge } from "@/components/ui/badge";
-import type { RendererProps, SemanticStatus } from "@/app/types";
 import { CreateRunDialog } from "@/app/components/CreateRunDialog";
+import type { DataTableColumn } from "@/app/components/entity";
+import {
+  DataTable,
+  EMPTY_COPY,
+  EmptyState,
+  EntityHeader,
+  EntityMetric,
+  KeyValueGrid,
+  StatusBadge,
+} from "@/app/components/entity";
+import { SnapshotDiffPanel } from "@/app/renderers/SnapshotViewer";
 import { workspaceApi } from "@/app/state/api";
-import { useUrlState } from "@/app/state/useUrlState";
+import { useNavigationState } from "@/app/state/useNavigationState";
+import type { RendererProps, RunSummary } from "@/app/types";
+import { Button } from "@/components/ui/button";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 
-const MetricStat = ({ label, value, icon: Icon, colorClass }: { label: string, value: number | string, icon: any, colorClass?: string }) => (
-  <div className="flex flex-col gap-1">
-     <div className="flex items-center gap-2 text-muted-foreground mb-1">
-        <Icon className={`h-4 w-4 ${colorClass || "text-muted-foreground"}`} />
-        <span className="text-xs font-medium uppercase tracking-wider">{label}</span>
-     </div>
-     <span className="text-3xl font-light tracking-tight text-foreground">{value}</span>
-  </div>
-);
-
-const StatusCell = ({ status }: { status: SemanticStatus }) => {
-    const styles = {
-        succeeded: "bg-green-500/10 text-green-700 hover:bg-green-500/20",
-        failed: "bg-red-500/10 text-red-700 hover:bg-red-500/20",
-        running: "bg-blue-500/10 text-blue-700 hover:bg-blue-500/20 animate-pulse",
-        pending: "bg-muted text-muted-foreground",
-        cancelled: "bg-muted text-muted-foreground strike-through",
-        active: "bg-muted",
-        archived: "bg-muted",
-        draft: "bg-amber-500/10 text-amber-700" 
-    };
-    return (
-        <Badge variant="secondary" className={`font-normal ${styles[status] || styles.pending}`}>
-            {status}
-        </Badge>
-    );
-};
-
 export const ExperimentViewer = ({
   selection,
   snapshot,
   onRefresh,
 }: RendererProps): JSX.Element => {
   const [isDeleting, setIsDeleting] = useState(false);
-  const { setSelection } = useUrlState();
+  const { setSelection, breadcrumbs, canNavigateUp, navigateUp } = useNavigationState(snapshot);
 
   // Find the experiment in snapshot
   const experimentId = selection.objectId;
   const experiment = snapshot.experiments.find((e) => e.id === experimentId);
   const projectId = experiment?.projectId || "";
-  
+
   // Filter runs for this experiment
-  const runs = useMemo(() => 
-    snapshot.runs.filter(r => r.experimentId === experimentId), 
-  [snapshot.runs, experimentId]);
+  const runs = useMemo(
+    () => snapshot.runs.filter((r) => r.experimentId === experimentId),
+    [snapshot.runs, experimentId],
+  );
 
   const stats = useMemo(() => {
-      return {
-          total: runs.length,
-          succeeded: runs.filter(r => r.status === "succeeded").length,
-          failed: runs.filter(r => r.status === "failed").length,
-          running: runs.filter(r => r.status === "running").length,
-      };
+    return {
+      total: runs.length,
+      succeeded: runs.filter((r) => r.status === "succeeded").length,
+      failed: runs.filter((r) => r.status === "failed").length,
+      running: runs.filter((r) => r.status === "running").length,
+    };
   }, [runs]);
 
   const handleDelete = async () => {
@@ -73,7 +54,7 @@ export const ExperimentViewer = ({
     setIsDeleting(true);
     try {
       await workspaceApi.deleteExperiment(projectId, experimentId);
-      onRefresh(); 
+      onRefresh();
     } catch (error) {
       console.error("Failed to delete experiment:", error);
       alert("Failed to delete experiment");
@@ -84,187 +65,218 @@ export const ExperimentViewer = ({
 
   const navigateToRun = (runId: string) => {
     setSelection({
-        objectType: "run",
-        objectId: runId,
+      objectType: "run",
+      objectId: runId,
     });
   };
 
   if (!experiment || !projectId) {
-    return <div className="p-8 text-muted-foreground">Experiment not found.</div>;
+    return (
+      <div className="flex h-full items-center justify-center bg-background">
+        <EmptyState
+          icon={<FileQuestion className="h-6 w-6" />}
+          title="Experiment not found"
+          description="It may have been deleted or not yet synced."
+        />
+      </div>
+    );
   }
 
+  const project = snapshot.projects.find((item) => item.id === projectId);
+  const workflow = snapshot.workflows.find(
+    (item) => item.name === experiment.workflowFile || item.id === experiment.workflowFile,
+  );
+
+  const runColumns: DataTableColumn<RunSummary>[] = [
+    {
+      key: "id",
+      header: "Run ID",
+      width: "w-[120px]",
+      cell: (run) => (
+        <span className="font-mono text-xs text-muted-foreground">{run.id.substring(0, 8)}</span>
+      ),
+    },
+    {
+      key: "status",
+      header: "Status",
+      width: "w-[140px]",
+      cell: (run) => <StatusBadge status={run.status} />,
+    },
+    {
+      key: "summary",
+      header: "Summary",
+      cell: (run) => (
+        <span className="block max-w-[200px] truncate text-muted-foreground" title={run.summary}>
+          {run.summary || "-"}
+        </span>
+      ),
+    },
+    {
+      key: "updated",
+      header: "Updated",
+      width: "w-[180px]",
+      cell: (run) => (
+        <span className="text-xs text-muted-foreground">
+          {new Date(run.updatedAt).toLocaleString()}
+        </span>
+      ),
+    },
+    {
+      key: "action",
+      header: "",
+      width: "w-[40px]",
+      align: "right",
+      cell: () => (
+        <Button
+          size="icon"
+          variant="ghost"
+          aria-label="Run again"
+          className="h-6 w-6 text-muted-foreground opacity-60 transition-opacity group-hover:opacity-100 hover:text-foreground"
+        >
+          <Play className="h-3.5 w-3.5" />
+        </Button>
+      ),
+    },
+  ];
+
   return (
     <div className="flex h-full flex-col bg-background">
-        {/* Header Hero */}
-        <div className="flex flex-col gap-6 px-8 py-8 border-b bg-background">
-            <div className="flex items-start justify-between">
-                <div className="space-y-1">
-                    <div className="flex items-center gap-3">
-                        <div className="p-2 bg-purple-500/10 rounded-lg">
-                            <FlaskConical className="h-6 w-6 text-purple-600" />
-                        </div>
-                        <h1 className="text-3xl font-bold tracking-tight text-foreground">{experiment.name}</h1>
-                    </div>
-                    <div className="flex items-center gap-2 pl-[3.25rem]">
-                        <Badge variant="outline" className="font-mono text-xs text-muted-foreground">
-                            {experimentId.substring(0,8)}
-                        </Badge>
-                        <span className="text-muted-foreground">•</span>
-                        <button 
-                             className="bg-muted px-1.5 py-0.5 rounded text-xs font-mono text-foreground hover:bg-muted/80 transition-colors cursor-pointer"
-                             onClick={() => {
-                                 // Assuming the workflow ID matches the name or we can derive it.
-                                 // For now using the filename as the ID or finding it from snapshot if possible.
-                                 // In the mock data, workflow ID usually matches or is referenced.
-                                 // But here we only have the filename string.
-                                 // Let's try to find a workflow with this name/file in snapshot 
-                                 // or just navigate to a workflow object with this ID.
-                                 const workflow = snapshot.workflows.find(w => w.name === experiment.workflowFile || w.id === experiment.workflowFile);
-                                 if (workflow) {
-                                     setSelection({
-                                         objectType: "workflow",
-                                         objectId: workflow.id,
-                                         workflowId: workflow.id
-                                     });
-                                 } else {
-                                     alert(`Workflow "${experiment.workflowFile}" not found in workspace.`);
-                                 }
-                             }}
-                        >
-                            {experiment.workflowFile || "workflow.json"}
-                        </button>
-                    </div>
-                </div>
-                <div className="flex items-center gap-2">
-                   <CreateRunDialog
-                        projectId={projectId}
-                        experimentId={experimentId}
-                        workflowFile={experiment?.workflowFile || ""} 
-                        onRunCreated={onRefresh}
-                      />
-                     <Button
-                        variant="ghost"
-                        size="icon"
-                        onClick={handleDelete}
-                        disabled={isDeleting}
-                        className="text-muted-foreground hover:text-destructive transition-colors"
-                        title="Delete Experiment"
-                     >
-                        <Trash2 className="h-5 w-5" />
-                     </Button>
-                </div>
-            </div>
+      <EntityHeader
+        breadcrumbs={breadcrumbs}
+        canNavigateUp={canNavigateUp}
+        onNavigateUp={navigateUp}
+        icon={FlaskConical}
+        title={experiment.name}
+        status={experiment.status}
+        subtitle={experiment.summary || undefined}
+        actions={
+          <>
+            <CreateRunDialog
+              projectId={projectId}
+              experimentId={experimentId}
+              workflowFile={experiment.workflowFile || ""}
+              onRunCreated={onRefresh}
+            />
+            <Button
+              variant="ghost"
+              size="icon"
+              onClick={handleDelete}
+              disabled={isDeleting}
+              className="h-7 w-7 text-muted-foreground hover:text-destructive"
+              aria-label="Delete experiment"
+              title="Delete experiment"
+            >
+              <Trash2 className="h-4 w-4" />
+            </Button>
+          </>
+        }
+        metrics={
+          <>
+            <EntityMetric label="Runs" value={stats.total} />
+            <EntityMetric label="Succeeded" value={stats.succeeded} />
+            <EntityMetric label="Failed" value={stats.failed} />
+            <EntityMetric label="Running" value={stats.running} />
+          </>
+        }
+      />
 
-            {/* Metrics Row */}
-            <div className="flex items-center gap-10 pl-[3.25rem] py-2">
-                <MetricStat 
-                    label="Runs" 
-                    value={stats.total} 
-                    icon={Activity} 
-                    colorClass="text-foreground"
-                />
-                <div className="h-10 w-px bg-border/50" />
-                <MetricStat 
-                    label="Succeeded" 
-                    value={stats.succeeded} 
-                    icon={CheckCircle2} 
-                    colorClass="text-green-500"
-                />
-                <div className="h-10 w-px bg-border/50" />
-                <MetricStat 
-                    label="Failed" 
-                    value={stats.failed} 
-                    icon={XCircle} 
-                    colorClass="text-red-500"
-                />
-                 <div className="h-10 w-px bg-border/50" />
-                <MetricStat 
-                    label="Running" 
-                    value={stats.running} 
-                    icon={Clock} 
-                    colorClass="text-blue-500"
+      <div className="flex-1 overflow-hidden flex flex-col">
+        <Tabs defaultValue="runs" className="flex flex-1 flex-col">
+          <div className="border-b border-border/70 bg-muted/20 px-4">
+            <TabsList className="h-auto w-fit justify-start gap-0 rounded-none bg-transparent p-0">
+              <TabsTrigger value="runs" className="rounded-none px-3 py-1.5 text-xs">
+                Runs
+              </TabsTrigger>
+              <TabsTrigger value="config" className="rounded-none px-3 py-1.5 text-xs">
+                Config
+              </TabsTrigger>
+              <TabsTrigger value="diff" className="rounded-none px-3 py-1.5 text-xs">
+                Diff
+              </TabsTrigger>
+            </TabsList>
+          </div>
+
+          <TabsContent value="runs" className="m-0 flex flex-1 flex-col overflow-hidden p-0">
+            <DataTable
+              columns={runColumns}
+              data={runs}
+              getRowKey={(run) => run.id}
+              onRowClick={(run) => navigateToRun(run.id)}
+              empty={
+                <EmptyState
+                  title={EMPTY_COPY.runs.title}
+                  description={EMPTY_COPY.runs.description}
                 />
-            </div>
-        </div>
+              }
+            />
+          </TabsContent>
+
+          <TabsContent value="config" className="flex-1 space-y-4 overflow-auto p-4">
+            <section>
+              <h3 className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+                Relationships
+              </h3>
+              <div className="mt-1.5 flex flex-wrap gap-1.5">
+                <Button
+                  variant="outline"
+                  size="sm"
+                  className="h-7 px-2 text-xs"
+                  onClick={() => setSelection({ objectType: "project", objectId: projectId })}
+                >
+                  Project: {project?.name || projectId}
+                </Button>
+                {workflow && (
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    className="h-7 px-2 text-xs"
+                    onClick={() =>
+                      setSelection({
+                        objectType: "workflow",
+                        objectId: workflow.id,
+                        workflowId: workflow.id,
+                      })
+                    }
+                  >
+                    Workflow: {workflow.name}
+                  </Button>
+                )}
+              </div>
+            </section>
 
-        {/* Content Tabs */}
-        <div className="flex-1 overflow-hidden flex flex-col">
-            <Tabs defaultValue="runs" className="flex-1 flex flex-col">
-                 <div className="px-8 py-3 border-b bg-background">
-                    <TabsList className="h-auto w-fit justify-start bg-muted/20 p-1 rounded-lg">
-                        <TabsTrigger 
-                            value="runs" 
-                            className="px-4 py-2 rounded-md font-medium text-sm"
-                        >
-                            Runs
-                        </TabsTrigger>
-                        <TabsTrigger 
-                            value="details" 
-                            className="px-4 py-2 rounded-md font-medium text-sm"
-                        >
-                            Details
-                        </TabsTrigger>
-                    </TabsList>
-                </div>
+            <section>
+              <h3 className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+                Summary
+              </h3>
+              <p className="mt-1.5 text-sm leading-5 text-foreground">
+                {experiment.summary || (
+                  <span className="text-muted-foreground">No summary provided.</span>
+                )}
+              </p>
+            </section>
 
-                <TabsContent value="runs" className="flex-1 p-0 m-0 overflow-hidden flex flex-col">
-                     <div className="flex-1 overflow-auto">
-                        <table className="w-full text-sm text-left">
-                            <thead className="bg-muted/20 text-muted-foreground font-medium sticky top-0 backdrop-blur-md">
-                                <tr>
-                                    <th className="py-3 px-6 w-[120px]">Run ID</th>
-                                    <th className="py-3 px-6 w-[140px]">Status</th>
-                                    <th className="py-3 px-6 w-auto">Summary</th>
-                                    <th className="py-3 px-6 w-[180px]">Updated</th>
-                                    <th className="py-3 px-6 w-[60px] text-right">Act</th>
-                                </tr>
-                            </thead>
-                            <tbody className="divide-y divide-border/50">
-                                {runs.length === 0 ? (
-                                    <tr>
-                                        <td colSpan={5} className="py-12 text-center text-muted-foreground">
-                                            No runs yet. Click "Start Run" to begin.
-                                        </td>
-                                    </tr>
-                                ) : (
-                                    runs.map((run) => (
-                                        <tr 
-                                            key={run.id}
-                                            className="group hover:bg-muted/40 transition-colors cursor-pointer"
-                                            onClick={() => navigateToRun(run.id)}
-                                        >
-                                            <td className="py-3 px-6 font-mono text-xs text-muted-foreground">
-                                                {run.id.substring(0, 8)}
-                                            </td>
-                                            <td className="py-3 px-6">
-                                                <StatusCell status={run.status} />
-                                            </td>
-                                            <td className="py-3 px-6 text-muted-foreground truncate max-w-[200px]" title={run.summary}>
-                                                {run.summary || "-"}
-                                            </td>
-                                            <td className="py-3 px-6 text-muted-foreground text-xs">
-                                                {new Date(run.updatedAt).toLocaleString()}
-                                            </td>
-                                            <td className="py-3 px-6 text-right">
-                                                 <Button size="icon" variant="ghost" className="h-8 w-8 opacity-0 group-hover:opacity-100 transition-opacity">
-                                                    <Play className="h-4 w-4 text-muted-foreground hover:text-foreground" />
-                                                </Button>
-                                            </td>
-                                        </tr>
-                                    ))
-                                )}
-                            </tbody>
-                        </table>
-                    </div>
-                </TabsContent>
+            <section>
+              <h3 className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+                Metadata
+              </h3>
+              <div className="mt-2">
+                <KeyValueGrid
+                  items={[
+                    { label: "Experiment ID", value: experiment.id },
+                    { label: "Project ID", value: projectId },
+                    { label: "Workflow File", value: experiment.workflowFile || "-" },
+                    { label: "Updated", value: new Date(experiment.updatedAt).toLocaleString() },
+                  ]}
+                />
+              </div>
+            </section>
+          </TabsContent>
 
-                <TabsContent value="details" className="flex-1 p-6 overflow-auto">
-                    <pre className="text-xs bg-muted/50 p-4 rounded-md overflow-auto font-mono">
-                        {JSON.stringify(experiment, null, 2)}
-                    </pre>
-                </TabsContent>
-            </Tabs>
-        </div>
+          <TabsContent value="diff" className="flex-1 p-0 m-0 overflow-hidden flex flex-col">
+            <SnapshotDiffPanel experimentRunIds={runs.map((r) => r.id)} />
+          </TabsContent>
+        </Tabs>
+      </div>
     </div>
   );
 };
diff --git a/ui/src/app/renderers/ImageViewer.tsx b/ui/src/app/renderers/ImageViewer.tsx
index ae50bd8f..ee447e91 100644
--- a/ui/src/app/renderers/ImageViewer.tsx
+++ b/ui/src/app/renderers/ImageViewer.tsx
@@ -1,8 +1,8 @@
 import { useEffect, useState } from "react";
+import { workspaceApi } from "@/app/state/api";
+import type { RendererProps } from "@/app/types";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Separator } from "@/components/ui/separator";
-import type { RendererProps } from "@/app/types";
-import { workspaceApi } from "@/app/state/api";
 
 export const ImageViewer = ({ selection }: RendererProps): JSX.Element => {
   const [imageUrl, setImageUrl] = useState<string | null>(null);
@@ -18,7 +18,7 @@ export const ImageViewer = ({ selection }: RendererProps): JSX.Element => {
 
     workspaceApi
       .getWorkspaceFileBlob(selection.objectId)
-      .then(blob => {
+      .then((blob) => {
         if (revoked) {
           return;
         }
@@ -26,7 +26,7 @@ export const ImageViewer = ({ selection }: RendererProps): JSX.Element => {
         setImageUrl(currentUrl);
         setError(null);
       })
-      .catch(err => {
+      .catch((err) => {
         setError(err instanceof Error ? err.message : "Failed to load image");
         setImageUrl(null);
       });
diff --git a/ui/src/app/renderers/MetadataInspector.tsx b/ui/src/app/renderers/MetadataInspector.tsx
index 8bb1a655..88f827be 100644
--- a/ui/src/app/renderers/MetadataInspector.tsx
+++ b/ui/src/app/renderers/MetadataInspector.tsx
@@ -1,36 +1,30 @@
-import { Badge } from "@/components/ui/badge";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { Separator } from "@/components/ui/separator";
-import type { RendererProps } from "@/app/types";
 import { buildMetadataFields } from "@/app/renderers/metadata";
+import type { RendererProps } from "@/app/types";
+import { Badge } from "@/components/ui/badge";
 
 export const MetadataInspector = ({ selection, snapshot }: RendererProps): JSX.Element => {
   const fields = buildMetadataFields(selection, snapshot);
 
   return (
-    <Card className="h-full border-border/60 bg-muted/30">
-      <CardHeader className="space-y-2">
-        <div className="flex items-center justify-between">
-          <CardTitle className="text-base font-semibold">Inspector</CardTitle>
-          <Badge variant="secondary" className="uppercase tracking-wide">
-            {selection.objectType}
-          </Badge>
-        </div>
-        <p className="text-xs text-muted-foreground">
-          Properties reflect the current selection and are read-only in this view.
-        </p>
-      </CardHeader>
-      <Separator />
-      <CardContent className="space-y-3 pt-4">
-        {fields.map(field => (
-          <div key={field.label} className="space-y-1">
-            <p className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">
+    <div className="flex h-full flex-col bg-background">
+      <div className="flex items-center justify-between border-b border-border/70 bg-muted/20 px-3 py-1.5">
+        <h2 className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+          Details
+        </h2>
+        <Badge variant="secondary" className="h-5 px-1.5 text-[10px] uppercase tracking-wide">
+          {selection.objectType}
+        </Badge>
+      </div>
+      <dl className="flex-1 divide-y divide-border/50 overflow-auto">
+        {fields.map((field) => (
+          <div key={field.label} className="px-3 py-1.5">
+            <dt className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
               {field.label}
-            </p>
-            <p className="text-sm font-medium text-foreground">{field.value}</p>
+            </dt>
+            <dd className="mt-0.5 break-words text-xs text-foreground">{field.value}</dd>
           </div>
         ))}
-      </CardContent>
-    </Card>
+      </dl>
+    </div>
   );
 };
diff --git a/ui/src/app/renderers/MetadataViewer.tsx b/ui/src/app/renderers/MetadataViewer.tsx
index baadb6f2..a971b45c 100644
--- a/ui/src/app/renderers/MetadataViewer.tsx
+++ b/ui/src/app/renderers/MetadataViewer.tsx
@@ -1,7 +1,7 @@
+import { buildMetadataFields } from "@/app/renderers/metadata";
+import type { RendererProps } from "@/app/types";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Separator } from "@/components/ui/separator";
-import type { RendererProps } from "@/app/types";
-import { buildMetadataFields } from "@/app/renderers/metadata";
 
 export const MetadataViewer = ({ selection, snapshot }: RendererProps): JSX.Element => {
   const fields = buildMetadataFields(selection, snapshot);
@@ -16,7 +16,7 @@ export const MetadataViewer = ({ selection, snapshot }: RendererProps): JSX.Elem
       </CardHeader>
       <Separator />
       <CardContent className="space-y-4 pt-4">
-        {fields.map(field => (
+        {fields.map((field) => (
           <div key={field.label} className="space-y-1">
             <p className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">
               {field.label}
diff --git a/ui/src/app/renderers/ProjectViewer.tsx b/ui/src/app/renderers/ProjectViewer.tsx
index 5a758f4b..f58bf120 100644
--- a/ui/src/app/renderers/ProjectViewer.tsx
+++ b/ui/src/app/renderers/ProjectViewer.tsx
@@ -1,53 +1,47 @@
-import { Trash2, Folder, FlaskConical, Play, Archive,  Activity } from "lucide-react";
-import { useState, useMemo, useEffect } from "react";
-import { Button } from "@/components/ui/button";
-import type { RendererProps, ApiAssetResponse } from "@/app/types";
+import { Archive, FlaskConical, FolderKanban, Play, Trash2 } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
 import { CreateExperimentDialog } from "@/app/components/CreateExperimentDialog";
+import type { DataTableColumn } from "@/app/components/entity";
+import {
+  DataTable,
+  EMPTY_COPY,
+  EmptyState,
+  EntityHeader,
+  EntityMetric,
+  StatusBadge,
+} from "@/app/components/entity";
 import { workspaceApi } from "@/app/state/api";
-import { useUrlState } from "@/app/state/useUrlState";
+import { useNavigationState } from "@/app/state/useNavigationState";
+import type { ApiAssetResponse, ExperimentSummary, RendererProps, RunSummary } from "@/app/types";
+import { Button } from "@/components/ui/button";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
-import { Badge } from "@/components/ui/badge";
-
-const MetricStat = ({ label, value, icon: Icon, colorClass }: { label: string, value: number | string, icon: any, colorClass?: string }) => (
-  <div className="flex flex-col gap-1">
-     <div className="flex items-center gap-2 text-muted-foreground mb-1">
-        <Icon className={`h-4 w-4 ${colorClass || "text-muted-foreground"}`} />
-        <span className="text-xs font-medium uppercase tracking-wider">{label}</span>
-     </div>
-     <span className="text-3xl font-light tracking-tight text-foreground">{value}</span>
-  </div>
-);
 
-export const ProjectViewer = ({
-  selection,
-  snapshot,
-  onRefresh,
-}: RendererProps): JSX.Element => {
+export const ProjectViewer = ({ selection, snapshot, onRefresh }: RendererProps): JSX.Element => {
   const [isDeleting, setIsDeleting] = useState(false);
   const [projectAssets, setProjectAssets] = useState<ApiAssetResponse[]>([]);
-  const { setSelection } = useUrlState();
+  const { setSelection, breadcrumbs, canNavigateUp, navigateUp } = useNavigationState(snapshot);
 
-  // Extract project name/id from selection
   const projectId = selection.objectId;
   const project = snapshot.projects.find((p) => p.id === projectId);
-  
-  // Fetch project assets
+
   useEffect(() => {
-      if (projectId) {
-          workspaceApi.getProjectAssets(projectId)
-            .then(setProjectAssets)
-            .catch(err => console.error("Failed to load project assets", err));
-      }
-  }, [projectId, onRefresh]);
-  
-  // Filter experiments and runs
-  const projectExperiments = useMemo(() => 
-    snapshot.experiments.filter(e => e.projectId === projectId),
-  [snapshot.experiments, projectId]);
+    if (projectId) {
+      workspaceApi
+        .getProjectAssets(projectId)
+        .then(setProjectAssets)
+        .catch((err) => console.error("Failed to load project assets", err));
+    }
+  }, [projectId]);
+
+  const projectExperiments = useMemo(
+    () => snapshot.experiments.filter((e) => e.projectId === projectId),
+    [snapshot.experiments, projectId],
+  );
 
-  const projectRuns = useMemo(() => 
-      snapshot.runs.filter(r => r.projectId === projectId),
-  [snapshot.runs, projectId]);
+  const projectRuns = useMemo(
+    () => snapshot.runs.filter((r) => r.projectId === projectId),
+    [snapshot.runs, projectId],
+  );
 
   const handleDelete = async () => {
     if (!confirm(`Are you sure you want to delete project "${projectId}"?`)) {
@@ -56,7 +50,7 @@ export const ProjectViewer = ({
     setIsDeleting(true);
     try {
       await workspaceApi.deleteProject(projectId);
-      onRefresh(); 
+      onRefresh();
     } catch (error) {
       console.error("Failed to delete project:", error);
       alert("Failed to delete project");
@@ -67,213 +61,256 @@ export const ProjectViewer = ({
 
   const navigateToExperiment = (experimentId: string) => {
     setSelection({
-        objectType: "experiment",
-        objectId: experimentId,
+      objectType: "experiment",
+      objectId: experimentId,
     });
   };
 
   if (!project) return <div className="p-8 text-muted-foreground">Project not found.</div>;
 
+  const experimentColumns: DataTableColumn<ExperimentSummary>[] = [
+    {
+      key: "name",
+      header: "Experiment Name",
+      cell: (exp) => (
+        <div className="flex items-center gap-3">
+          <div className="rounded-md bg-purple-500/10 p-1.5 text-purple-600 transition-colors group-hover:bg-purple-500/20">
+            <FlaskConical className="h-4 w-4" />
+          </div>
+          <span className="font-medium text-foreground">{exp.name}</span>
+        </div>
+      ),
+    },
+    {
+      key: "id",
+      header: "ID",
+      width: "w-[120px]",
+      cell: (exp) => (
+        <span className="font-mono text-xs text-muted-foreground">{exp.id.substring(0, 8)}</span>
+      ),
+    },
+    {
+      key: "status",
+      header: "Status",
+      width: "w-[160px]",
+      cell: (exp) => <StatusBadge status={exp.status} />,
+    },
+    {
+      key: "updated",
+      header: "Updated",
+      width: "w-[180px]",
+      cell: (exp) => (
+        <span className="text-muted-foreground">
+          {new Date(exp.updatedAt).toLocaleDateString()}
+        </span>
+      ),
+    },
+    {
+      key: "action",
+      header: "Action",
+      width: "w-[60px]",
+      align: "right",
+      cell: () => (
+        <Button
+          size="icon"
+          variant="ghost"
+          className="h-8 w-8 opacity-0 transition-opacity group-hover:opacity-100"
+        >
+          <Play className="h-4 w-4 text-muted-foreground hover:text-foreground" />
+        </Button>
+      ),
+    },
+  ];
+
+  const runColumns: DataTableColumn<RunSummary>[] = [
+    {
+      key: "run",
+      header: "Run",
+      cell: (run) => (
+        <>
+          <div className="font-medium text-foreground">{run.name || run.id}</div>
+          <div className="font-mono text-xs text-muted-foreground">{run.id}</div>
+        </>
+      ),
+    },
+    {
+      key: "experiment",
+      header: "Experiment",
+      width: "w-[220px]",
+      cell: (run) => {
+        const experiment = snapshot.experiments.find((item) => item.id === run.experimentId);
+        return (
+          <span className="text-muted-foreground">{experiment?.name || run.experimentId}</span>
+        );
+      },
+    },
+    {
+      key: "status",
+      header: "Status",
+      width: "w-[140px]",
+      cell: (run) => <StatusBadge status={run.status} />,
+    },
+    {
+      key: "updated",
+      header: "Updated",
+      width: "w-[180px]",
+      cell: (run) => (
+        <span className="text-muted-foreground">{new Date(run.updatedAt).toLocaleString()}</span>
+      ),
+    },
+  ];
+
+  const assetColumns: DataTableColumn<ApiAssetResponse>[] = [
+    {
+      key: "name",
+      header: "Asset Name",
+      cell: (asset) => (
+        <div className="flex items-center gap-2 font-medium">
+          <Archive className="h-4 w-4 text-amber-500" />
+          {asset.assetId}
+        </div>
+      ),
+    },
+    {
+      key: "type",
+      header: "Type",
+      width: "w-[150px]",
+      cell: (asset) => <span className="text-muted-foreground">{asset.format}</span>,
+    },
+    {
+      key: "size",
+      header: "Size",
+      width: "w-[120px]",
+      cell: (asset) => <span className="font-mono text-xs">{asset.size} B</span>,
+    },
+    {
+      key: "created",
+      header: "Created",
+      width: "w-[180px]",
+      cell: (asset) => (
+        <span className="text-muted-foreground">
+          {new Date(asset.created).toLocaleDateString()}
+        </span>
+      ),
+    },
+  ];
+
   return (
     <div className="flex h-full flex-col bg-background">
-        {/* Header Hero */}
-        <div className="flex flex-col gap-6 px-8 py-8 border-b bg-background">
-            <div className="flex items-start justify-between">
-                <div className="space-y-1">
-                    <div className="flex items-center gap-3">
-                        <div className="p-2 bg-blue-500/10 rounded-lg">
-                            <Folder className="h-6 w-6 text-blue-600" />
-                        </div>
-                        <h1 className="text-3xl font-bold tracking-tight text-foreground">{project.name}</h1>
-                        <Badge variant="outline" className="ml-2 font-mono text-xs text-muted-foreground">
-                            {projectId.substring(0,8)}
-                        </Badge>
-                    </div>
-                    <p className="text-muted-foreground max-w-2xl pl-[3.25rem]">
-                        {project.summary || "No description provided."}
-                    </p>
-                </div>
-                <div className="flex items-center gap-2">
-                     <CreateExperimentDialog
-                        projectId={projectId}
-                        onExperimentCreated={onRefresh}
-                     />
-                     <Button
-                        variant="ghost"
-                        size="icon"
-                        onClick={handleDelete}
-                        disabled={isDeleting}
-                        className="text-muted-foreground hover:text-destructive transition-colors"
-                        title="Delete Project"
-                     >
-                        <Trash2 className="h-5 w-5" />
-                     </Button>
-                </div>
-            </div>
+      <EntityHeader
+        breadcrumbs={breadcrumbs}
+        canNavigateUp={canNavigateUp}
+        onNavigateUp={navigateUp}
+        icon={FolderKanban}
+        title={project.name}
+        status={project.status}
+        subtitle={project.summary || undefined}
+        actions={
+          <>
+            <CreateExperimentDialog projectId={projectId} onExperimentCreated={onRefresh} />
+            <Button
+              variant="ghost"
+              size="icon"
+              onClick={handleDelete}
+              disabled={isDeleting}
+              className="text-muted-foreground hover:text-destructive"
+              title="Delete Project"
+            >
+              <Trash2 className="h-5 w-5" />
+            </Button>
+          </>
+        }
+        metrics={
+          <>
+            <EntityMetric label="Experiments" value={projectExperiments.length} />
+            <EntityMetric label="Runs" value={projectRuns.length} />
+            <EntityMetric label="Assets" value={projectAssets.length} />
+          </>
+        }
+      />
 
-            {/* Metrics Row */}
-            <div className="flex items-center gap-12 pl-[3.25rem] py-2">
-                <MetricStat 
-                    label="Experiments" 
-                    value={projectExperiments.length} 
-                    icon={FlaskConical} 
-                    colorClass="text-purple-500"
-                />
-                <div className="h-12 w-px bg-border/50" />
-                <MetricStat 
-                    label="Total Runs" 
-                    value={projectRuns.length} 
-                    icon={Activity} 
-                    colorClass="text-emerald-500"
-                />
-                <div className="h-12 w-px bg-border/50" />
-                <MetricStat 
-                    label="Project Assets" 
-                    value={projectAssets.length} 
-                    icon={Archive} 
-                    colorClass="text-amber-500"
+      <div className="flex-1 flex flex-col overflow-hidden">
+        <Tabs defaultValue="experiments" className="flex-1 flex flex-col">
+          <div className="border-b border-border/70 bg-muted/10 px-6 py-2 md:px-8">
+            <TabsList className="h-auto w-fit justify-start rounded-md bg-transparent p-0">
+              <TabsTrigger value="experiments" className="rounded-md px-4 py-2 text-sm font-medium">
+                Experiments
+              </TabsTrigger>
+              <TabsTrigger value="runs" className="rounded-md px-4 py-2 text-sm font-medium">
+                Runs
+              </TabsTrigger>
+              <TabsTrigger value="assets" className="rounded-md px-4 py-2 text-sm font-medium">
+                Assets
+              </TabsTrigger>
+              <TabsTrigger value="settings" className="rounded-md px-4 py-2 text-sm font-medium">
+                Settings
+              </TabsTrigger>
+            </TabsList>
+          </div>
+
+          <TabsContent value="experiments" className="m-0 flex flex-1 flex-col overflow-hidden p-0">
+            <DataTable
+              columns={experimentColumns}
+              data={projectExperiments}
+              getRowKey={(exp) => exp.id}
+              onRowClick={(exp) => navigateToExperiment(exp.id)}
+              empty={
+                <EmptyState
+                  title={EMPTY_COPY.experiments.title}
+                  description={EMPTY_COPY.experiments.description}
                 />
-            </div>
-        </div>
+              }
+            />
+          </TabsContent>
 
-        {/* Content Tabs */}
-        <div className="flex-1 overflow-hidden flex flex-col">
-            <Tabs defaultValue="experiments" className="flex-1 flex flex-col">
-                <div className="px-8 py-3 border-b bg-background">
-                    <TabsList className="h-auto w-fit justify-start bg-muted/20 p-1 rounded-lg">
-                        <TabsTrigger 
-                            value="experiments" 
-                            className="px-4 py-2 rounded-md font-medium text-sm"
-                        >
-                            Experiments
-                        </TabsTrigger>
-                        <TabsTrigger 
-                            value="assets" 
-                            className="px-4 py-2 rounded-md font-medium text-sm"
-                        >
-                            Assets
-                        </TabsTrigger>
-                        <TabsTrigger 
-                            value="settings" 
-                            className="px-4 py-2 rounded-md font-medium text-sm"
-                        >
-                            Settings
-                        </TabsTrigger>
-                    </TabsList>
-                </div>
+          <TabsContent value="runs" className="m-0 flex flex-1 flex-col overflow-hidden p-0">
+            <DataTable
+              columns={runColumns}
+              data={projectRuns}
+              getRowKey={(run) => run.id}
+              onRowClick={(run) => setSelection({ objectType: "run", objectId: run.id })}
+              empty={
+                <EmptyState
+                  title={EMPTY_COPY.projectRuns.title}
+                  description={EMPTY_COPY.projectRuns.description}
+                />
+              }
+            />
+          </TabsContent>
 
-                <TabsContent value="experiments" className="flex-1 p-0 m-0 overflow-hidden flex flex-col">
-                    <div className="flex-1 overflow-auto">
-                         <table className="w-full text-sm text-left">
-                            <thead className="bg-muted/20 text-muted-foreground font-medium sticky top-0 backdrop-blur-md">
-                                <tr>
-                                    <th className="py-3 px-6 w-auto">Experiment Name</th>
-                                    <th className="py-3 px-6 w-[120px]">ID</th>
-                                    <th className="py-3 px-6 w-[160px]">Status</th>
-                                    <th className="py-3 px-6 w-[180px]">Updated</th>
-                                    <th className="py-3 px-6 w-[60px] text-right">Action</th>
-                                </tr>
-                            </thead>
-                            <tbody className="divide-y divide-border/50">
-                                {projectExperiments.length === 0 ? (
-                                    <tr>
-                                        <td colSpan={5} className="py-12 text-center text-muted-foreground">
-                                            No experiments yet. Click "Create Experiment" to start.
-                                        </td>
-                                    </tr>
-                                ) : (
-                                    projectExperiments.map((exp) => (
-                                        <tr 
-                                            key={exp.id}
-                                            className="group hover:bg-muted/40 transition-colors cursor-pointer"
-                                            onClick={() => navigateToExperiment(exp.id)}
-                                        >
-                                            <td className="py-3 px-6">
-                                                <div className="flex items-center gap-3">
-                                                    <div className="p-1.5 rounded-md bg-purple-500/10 text-purple-600 group-hover:bg-purple-500/20 transition-colors">
-                                                        <FlaskConical className="h-4 w-4" />
-                                                    </div>
-                                                    <span className="font-medium text-foreground">{exp.name}</span>
-                                                </div>
-                                            </td>
-                                            <td className="py-3 px-6 font-mono text-xs text-muted-foreground">{exp.id.substring(0,8)}</td>
-                                            <td className="py-3 px-6">
-                                                <Badge variant="secondary" className="font-normal">Active</Badge>
-                                            </td>
-                                            <td className="py-3 px-6 text-muted-foreground">
-                                                {new Date(exp.updatedAt).toLocaleDateString()}
-                                            </td>
-                                            <td className="py-3 px-6 text-right">
-                                                <Button size="icon" variant="ghost" className="h-8 w-8 opacity-0 group-hover:opacity-100 transition-opacity">
-                                                    <Play className="h-4 w-4 text-muted-foreground hover:text-foreground" />
-                                                </Button>
-                                            </td>
-                                        </tr>
-                                    ))
-                                )}
-                            </tbody>
-                        </table>
-                    </div>
-                </TabsContent>
+          <TabsContent value="assets" className="m-0 flex flex-1 flex-col overflow-hidden p-0">
+            <DataTable
+              columns={assetColumns}
+              data={projectAssets}
+              getRowKey={(asset) => asset.id}
+              empty={
+                <EmptyState
+                  title={EMPTY_COPY.assets.title}
+                  description={EMPTY_COPY.assets.description}
+                />
+              }
+            />
+          </TabsContent>
 
-                <TabsContent value="assets" className="flex-1 p-0 m-0 overflow-hidden flex flex-col">
-                    <div className="flex-1 overflow-auto">
-                        <table className="w-full text-sm text-left">
-                            <thead className="bg-muted/20 text-muted-foreground font-medium sticky top-0 backdrop-blur-md">
-                                <tr>
-                                    <th className="py-3 px-6 w-auto">Asset Name</th>
-                                    <th className="py-3 px-6 w-[150px]">Type</th>
-                                    <th className="py-3 px-6 w-[120px]">Size</th>
-                                    <th className="py-3 px-6 w-[180px]">Created</th>
-                                </tr>
-                            </thead>
-                            <tbody className="divide-y divide-border/50">
-                                {projectAssets.length === 0 ? (
-                                    <tr>
-                                        <td colSpan={4} className="py-12 text-center text-muted-foreground">
-                                            No assets found in this project.
-                                        </td>
-                                    </tr>
-                                ) : (
-                                    projectAssets.map((asset) => (
-                                        <tr key={asset.id} className="hover:bg-muted/40 transition-colors">
-                                            <td className="py-3 px-6 font-medium">
-                                                <div className="flex items-center gap-3">
-                                                     <div className="p-1.5 rounded-md bg-amber-500/10 text-amber-600">
-                                                        <Archive className="h-4 w-4" />
-                                                    </div>
-                                                    {asset.assetId}
-                                                </div>
-                                            </td>
-                                            <td className="py-3 px-6 text-muted-foreground">{asset.format}</td>
-                                            <td className="py-3 px-6 font-mono text-xs">{asset.size} B</td>
-                                            <td className="py-3 px-6 text-muted-foreground">
-                                                {new Date(asset.created).toLocaleDateString()}
-                                            </td>
-                                        </tr>
-                                    ))
-                                )}
-                            </tbody>
-                         </table>
-                    </div>
-                </TabsContent>
-                
-                <TabsContent value="settings" className="flex-1 p-6">
-                    <div className="max-w-xl space-y-4">
-                        <div className="p-4 rounded-lg border bg-card text-card-foreground shadow-sm">
-                            <h3 className="text-lg font-medium mb-2">Project Settings</h3>
-                            <p className="text-sm text-muted-foreground mb-4">
-                                Manage project-level configurations and danger zones.
-                            </p>
-                            <Button variant="destructive" onClick={handleDelete} disabled={isDeleting}>
-                                <Trash2 className="mr-2 h-4 w-4" />
-                                Delete Project
-                            </Button>
-                        </div>
-                    </div>
-                </TabsContent>
-            </Tabs>
-        </div>
+          <TabsContent value="settings" className="flex-1 p-6">
+            <div className="max-w-2xl space-y-5">
+              <div className="border-b border-border/70 pb-4">
+                <h3 className="text-sm font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+                  Danger Zone
+                </h3>
+                <p className="mt-2 text-sm text-muted-foreground">
+                  Deleting a project removes access to its experiment and run hierarchy from this
+                  workspace view.
+                </p>
+              </div>
+              <Button variant="destructive" onClick={handleDelete} disabled={isDeleting}>
+                <Trash2 className="mr-2 h-4 w-4" />
+                Delete Project
+              </Button>
+            </div>
+          </TabsContent>
+        </Tabs>
+      </div>
     </div>
   );
 };
diff --git a/ui/src/app/renderers/RunViewer.tsx b/ui/src/app/renderers/RunViewer.tsx
index 6791da5c..020aeafa 100644
--- a/ui/src/app/renderers/RunViewer.tsx
+++ b/ui/src/app/renderers/RunViewer.tsx
@@ -1,183 +1,141 @@
-import { FileText, CheckCircle2, XCircle, AlertCircle, Clock, Activity, Box, Terminal } from "lucide-react";
+import { FileQuestion, FileText, Terminal } from "lucide-react";
 import { useMemo } from "react";
-import { Badge } from "@/components/ui/badge";
-import type { RendererProps, SemanticStatus } from "@/app/types";
+import { EmptyState, EntityHeader, KeyValueGrid } from "@/app/components/entity";
 import { buildMetadataFields } from "@/app/renderers/metadata";
+import { RunSnapshotPanel } from "@/app/renderers/SnapshotViewer";
+import { useNavigationState } from "@/app/state/useNavigationState";
+import type { RendererProps } from "@/app/types";
+import { Button } from "@/components/ui/button";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 
-const MetricStat = ({ label, value, icon: Icon, colorClass }: { label: string, value: number | string, icon: any, colorClass?: string }) => (
-  <div className="flex flex-col gap-1">
-     <div className="flex items-center gap-2 text-muted-foreground mb-1">
-        <Icon className={`h-4 w-4 ${colorClass || "text-muted-foreground"}`} />
-        <span className="text-xs font-medium uppercase tracking-wider">{label}</span>
-     </div>
-     <span className="text-3xl font-light tracking-tight text-foreground">{value}</span>
-  </div>
-);
-
-const StatusBadge = ({ status }: { status: SemanticStatus }) => {
-  if (status === "succeeded") {
-    return (
-      <Badge variant="default" className="bg-green-600 hover:bg-green-700 gap-1.5 pl-1.5 pr-2.5 py-1">
-        <CheckCircle2 className="h-4 w-4" /> Succeeded
-      </Badge>
-    );
-  }
-  if (status === "failed") {
-    return (
-      <Badge variant="destructive" className="gap-1.5 pl-1.5 pr-2.5 py-1">
-        <XCircle className="h-4 w-4" /> Failed
-      </Badge>
-    );
-  }
-  if (status === "running") {
-    return (
-      <Badge variant="secondary" className="bg-blue-100 text-blue-800 hover:bg-blue-200 gap-1.5 pl-1.5 pr-2.5 py-1 animate-pulse">
-        <Activity className="h-4 w-4" /> Running
-      </Badge>
-    );
-  }
-  if (status === "cancelled") {
-    return (
-      <Badge variant="secondary" className="gap-1.5 pl-1.5 pr-2.5 py-1">
-        <AlertCircle className="h-4 w-4" /> Cancelled
-      </Badge>
-    );
-  }
-  return (
-    <Badge variant="outline" className="gap-1.5 pl-1.5 pr-2.5 py-1">
-      <Clock className="h-4 w-4" /> {status}
-    </Badge>
-  );
-};
-
 export const RunViewer = ({ selection, snapshot }: RendererProps): JSX.Element => {
+  const { setSelection, breadcrumbs, canNavigateUp, navigateUp } = useNavigationState(snapshot);
   const fields = buildMetadataFields(selection, snapshot);
-  
+
   const run = useMemo(() => {
-     return snapshot.runs.find(r => r.id === selection.objectId);
+    return snapshot.runs.find((r) => r.id === selection.objectId);
   }, [snapshot.runs, selection.objectId]);
 
   if (!run) {
-    return <div className="p-8 text-muted-foreground">Run not found.</div>;
+    return (
+      <div className="flex h-full items-center justify-center bg-background">
+        <EmptyState
+          icon={<FileQuestion className="h-6 w-6" />}
+          title="Run not found"
+          description="It may have been deleted or not yet synced."
+        />
+      </div>
+    );
   }
 
+  const project = snapshot.projects.find((item) => item.id === run.projectId);
+  const experiment = snapshot.experiments.find((item) => item.id === run.experimentId);
+
   // Filter interesting fields to show in the table
-  const displayFields = fields.filter(f => 
-    !["Run", "Status", "Summary", "Project", "Experiment"].includes(f.label)
+  const displayFields = fields.filter(
+    (f) => !["Run", "Status", "Summary", "Project", "Experiment"].includes(f.label),
   );
 
   return (
     <div className="flex h-full flex-col bg-background">
-        {/* Header Hero */}
-        <div className="flex flex-col gap-6 px-8 py-8 border-b bg-background">
-            <div className="flex items-start justify-between">
-                <div className="space-y-1">
-                    <div className="flex items-center gap-3">
-                        <div className="p-2 bg-blue-500/10 rounded-lg">
-                            <FileText className="h-6 w-6 text-blue-600" />
-                        </div>
-                        <h1 className="text-3xl font-bold tracking-tight text-foreground">{run.name}</h1>
-                        <Badge variant="outline" className="font-mono text-xs text-muted-foreground ml-2">
-                            {run.id}
-                        </Badge>
-                    </div>
-                     <div className="flex items-center gap-2 pl-[3.25rem]">
-                         <StatusBadge status={run.status} />
-                     </div>
-                </div>
-                {/* Placeholder for Actions */}
-            </div>
+      <EntityHeader
+        breadcrumbs={breadcrumbs}
+        canNavigateUp={canNavigateUp}
+        onNavigateUp={navigateUp}
+        icon={FileText}
+        title={run.name}
+        status={run.status}
+        subtitle={run.summary || undefined}
+      />
 
-            {/* Metrics Row */}
-            <div className="flex items-center gap-12 pl-[3.25rem] py-2">
-                <MetricStat 
-                    label="Updated" 
-                    value={new Date(run.updatedAt).toLocaleTimeString()} 
-                    icon={Clock} 
-                />
-                 {/* Placeholders for future metrics */}
-            </div>
-        </div>
+      <div className="flex-1 overflow-hidden flex flex-col">
+        <Tabs defaultValue="overview" className="flex flex-1 flex-col">
+          <div className="border-b border-border/70 bg-muted/20 px-4">
+            <TabsList className="h-auto w-fit justify-start gap-0 rounded-none bg-transparent p-0">
+              <TabsTrigger value="overview" className="rounded-none px-3 py-1.5 text-xs">
+                Overview
+              </TabsTrigger>
+              <TabsTrigger value="logs" className="rounded-none px-3 py-1.5 text-xs">
+                Logs
+              </TabsTrigger>
+              <TabsTrigger value="snapshot" className="rounded-none px-3 py-1.5 text-xs">
+                Snapshot
+              </TabsTrigger>
+            </TabsList>
+          </div>
 
-        {/* Content Tabs */}
-        <div className="flex-1 overflow-hidden flex flex-col">
-            <Tabs defaultValue="overview" className="flex-1 flex flex-col">
-                 <div className="px-8 py-3 border-b bg-background">
-                    <TabsList className="h-auto w-fit justify-start bg-muted/20 p-1 rounded-lg">
-                        <TabsTrigger 
-                            value="overview" 
-                            className="px-4 py-2 rounded-md font-medium text-sm"
-                        >
-                            Overview
-                        </TabsTrigger>
-                        <TabsTrigger 
-                            value="logs" 
-                            className="px-4 py-2 rounded-md font-medium text-sm"
-                        >
-                            Logs
-                        </TabsTrigger>
-                         <TabsTrigger 
-                            value="artifacts" 
-                            className="px-4 py-2 rounded-md font-medium text-sm"
-                        >
-                            Artifacts
-                        </TabsTrigger>
-                    </TabsList>
+          <TabsContent value="overview" className="m-0 flex flex-1 flex-col overflow-hidden p-0">
+            <div className="flex-1 space-y-4 overflow-auto p-4">
+              <section>
+                <h3 className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+                  Relationships
+                </h3>
+                <div className="mt-1.5 flex flex-wrap gap-1.5">
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    className="h-7 px-2 text-xs"
+                    onClick={() =>
+                      setSelection({ objectType: "project", objectId: run.projectId })
+                    }
+                  >
+                    Project: {project?.name || run.projectId}
+                  </Button>
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    className="h-7 px-2 text-xs"
+                    onClick={() =>
+                      setSelection({ objectType: "experiment", objectId: run.experimentId })
+                    }
+                  >
+                    Experiment: {experiment?.name || run.experimentId}
+                  </Button>
                 </div>
+              </section>
 
-                <TabsContent value="overview" className="flex-1 p-0 m-0 overflow-hidden flex flex-col">
-                    <div className="flex-1 overflow-auto">
-                         <table className="w-full text-sm text-left">
-                            <tbody className="divide-y divide-border/50">
-                                {displayFields.length === 0 ? (
-                                    <tr>
-                                        <td colSpan={2} className="py-12 text-center text-muted-foreground">
-                                            No additional details.
-                                        </td>
-                                    </tr>
-                                ) : (
-                                    displayFields.map((field, i) => (
-                                        <tr key={i} className="hover:bg-muted/30 transition-colors">
-                                            <td className="py-3 px-6 font-medium text-muted-foreground w-[200px]">
-                                                {field.label}
-                                            </td>
-                                            <td className="py-3 px-6 font-mono text-xs">
-                                                {field.value}
-                                            </td>
-                                        </tr>
-                                    ))
-                                )}
-                            </tbody>
-                        </table>
-                        
-                        <div className="p-6">
-                            <h3 className="text-sm font-medium text-muted-foreground mb-3 uppercase tracking-wider">Summary</h3>
-                             <div className="p-4 rounded-lg bg-muted/30 border text-sm">
-                                {run.summary || "No summary provided."}
-                            </div>
-                        </div>
-                    </div>
-                </TabsContent>
+              <section>
+                <h3 className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+                  Summary
+                </h3>
+                <p className="mt-1.5 text-sm leading-5 text-foreground">
+                  {run.summary || (
+                    <span className="text-muted-foreground">No summary provided.</span>
+                  )}
+                </p>
+              </section>
 
-                <TabsContent value="logs" className="flex-1 p-0 flex flex-col bg-slate-950 text-slate-50">
-                     <div className="flex items-center px-4 py-2 border-b border-slate-800 bg-slate-900 text-xs font-mono text-slate-400">
-                        <Terminal className="h-3 w-3 mr-2" />
-                        stdout/stderr
-                     </div>
-                     <div className="flex-1 p-4 font-mono text-xs overflow-auto">
-                        <div className="opacity-50 italic">Log streaming not implemented yet.</div>
-                     </div>
-                </TabsContent>
+              <section>
+                <h3 className="text-[11px] font-medium uppercase tracking-wide text-muted-foreground">
+                  Metadata
+                </h3>
+                <div className="mt-2">
+                  <KeyValueGrid
+                    items={displayFields.map((field) => ({
+                      label: field.label,
+                      value: <span className="font-mono text-xs">{field.value}</span>,
+                    }))}
+                  />
+                </div>
+              </section>
+            </div>
+          </TabsContent>
+
+          <TabsContent value="logs" className="m-0 flex flex-1 flex-col overflow-hidden bg-zinc-950 p-0 text-zinc-50 dark:bg-black">
+            <div className="flex items-center gap-2 border-b border-zinc-800 bg-zinc-900 px-3 py-1 font-mono text-[11px] text-zinc-400">
+              <Terminal className="h-3 w-3" />
+              stdout/stderr
+            </div>
+            <div className="flex-1 overflow-auto p-3 font-mono text-xs">
+              <div className="italic opacity-60">Log streaming not implemented yet.</div>
+            </div>
+          </TabsContent>
 
-                 <TabsContent value="artifacts" className="flex-1 p-0 flex flex-col">
-                     <div className="flex-1 p-8 flex flex-col items-center justify-center text-muted-foreground">
-                        <Box className="h-12 w-12 mb-4 opacity-20" />
-                        <div>No artifacts generated.</div>
-                     </div>
-                </TabsContent>
-            </Tabs>
-        </div>
+          <TabsContent value="snapshot" className="flex-1 p-0 m-0 overflow-hidden flex flex-col">
+            <RunSnapshotPanel runId={run.id} />
+          </TabsContent>
+        </Tabs>
+      </div>
     </div>
   );
 };
diff --git a/ui/src/app/renderers/SnapshotViewer.tsx b/ui/src/app/renderers/SnapshotViewer.tsx
new file mode 100644
index 00000000..6837cc45
--- /dev/null
+++ b/ui/src/app/renderers/SnapshotViewer.tsx
@@ -0,0 +1,876 @@
+/**
+ * Snapshot & Diff components.
+ *
+ * Architecture:
+ *   - Run    → fixed snapshot   → <RunSnapshotPanel>   (read-only list)
+ *   - Experiment → compare runs → <SnapshotDiffPanel>  (pick two runs, show diff)
+ *
+ * Both panels are exported for use in RunViewer and ExperimentViewer respectively.
+ */
+
+import {
+  AlertCircle,
+  CheckCircle2,
+  ChevronDown,
+  ChevronRight,
+  Code,
+  Database,
+  GitCompareArrows,
+  Hash,
+  Settings,
+} from "lucide-react";
+import { useMemo, useState } from "react";
+import type { TaskSnapshotResponse } from "@/api/generated/models/TaskSnapshotResponse";
+import { Badge } from "@/components/ui/badge";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+type FieldStatus = "unchanged" | "modified" | "added" | "removed";
+
+interface TaskDiff {
+  taskId: string;
+  taskType: string;
+  status: FieldStatus;
+  codeChanged: boolean;
+  configChanged: boolean;
+  oldSnapshot: TaskSnapshotResponse | null;
+  newSnapshot: TaskSnapshotResponse | null;
+}
+
+/** A snapshot set attached to a single run. */
+export interface RunSnapshotSet {
+  runId: string;
+  runLabel: string;
+  createdAt: string;
+  snapshots: TaskSnapshotResponse[];
+}
+
+// ============================================================================
+// Mock data
+// ============================================================================
+
+const MOCK_RUN_SNAPSHOTS: Record<string, RunSnapshotSet> = {
+  "run-001": {
+    runId: "run-001",
+    runLabel: "run-001 (latest)",
+    createdAt: "2026-02-13T08:30:00Z",
+    snapshots: [
+      {
+        taskId: "PrepareData_a1b2c3d4",
+        taskType: "PrepareData",
+        codeHash: "e7f3a09b16c2d481",
+        configHash: "3bc1f84e927da056",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    raw_path = Path(self.config.input_dir)
+    df = pd.read_parquet(raw_path / "molecules.parquet")
+    if self.config.shuffle:
+        df = df.sample(frac=1, random_state=42)
+    train, test = train_test_split(df, test_size=0.2)
+    return {"train": train, "test": test}`,
+        snapshotKey: "e7f3a09b16c2d481:3bc1f84e927da056",
+        createdAt: "2026-02-13T08:30:00Z",
+        configData: { input_dir: "/data/raw", format: "parquet", shuffle: true },
+      },
+      {
+        taskId: "TrainModel_e5f6a7b8",
+        taskType: "TrainModel",
+        codeHash: "a20c4f1d88e53b79",
+        configHash: "71d0e2ca5f38b614",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    train_data = inputs["train"]
+    model = GNNModel(version="v2", hidden_dim=128)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=self.config.lr)
+    scheduler = CosineAnnealingLR(optimizer, T_max=self.config.epochs)
+    for epoch in range(self.config.epochs):
+        loss = train_epoch(model, train_data, optimizer, self.config.batch_size)
+        scheduler.step()
+        if epoch % 50 == 0:
+            logger.info(f"Epoch {epoch}: loss={loss:.4f}")
+    return {"model": model, "final_loss": loss}`,
+        snapshotKey: "a20c4f1d88e53b79:71d0e2ca5f38b614",
+        createdAt: "2026-02-13T08:30:00Z",
+        configData: {
+          model: "gnn-v2",
+          epochs: 200,
+          lr: 0.0005,
+          batch_size: 64,
+          scheduler: "cosine",
+        },
+      },
+      {
+        taskId: "Evaluate_c9d0e1f2",
+        taskType: "Evaluate",
+        codeHash: "5b8d12ef6ca0793e",
+        configHash: "d4a176c023be8f51",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    model = inputs["model"]
+    test_data = inputs["test"]
+    predictions = model.predict(test_data)
+    results = {}
+    for metric in self.config.metrics:
+        results[metric] = compute_metric(metric, test_data.y, predictions)
+    return {"metrics": results}`,
+        snapshotKey: "5b8d12ef6ca0793e:d4a176c023be8f51",
+        createdAt: "2026-02-13T08:30:00Z",
+        configData: { metrics: ["mae", "rmse", "r2"], split: "test" },
+      },
+      {
+        taskId: "ExportReport_f3a4b5c6",
+        taskType: "ExportReport",
+        codeHash: "1c9e3d7f42b08a65",
+        configHash: "9fe2b8a04d61c73f",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    metrics = inputs["metrics"]
+    report = ReportBuilder(format=self.config.output_format)
+    report.add_section("Metrics", metrics)
+    if self.config.include_plots:
+        report.add_plots(generate_metric_plots(metrics))
+    output_path = report.save()
+    return {"report_path": str(output_path)}`,
+        snapshotKey: "1c9e3d7f42b08a65:9fe2b8a04d61c73f",
+        createdAt: "2026-02-13T08:30:00Z",
+        configData: { output_format: "html", include_plots: true },
+      },
+    ],
+  },
+  "run-002": {
+    runId: "run-002",
+    runLabel: "run-002",
+    createdAt: "2026-02-12T14:00:00Z",
+    snapshots: [
+      {
+        taskId: "PrepareData_a1b2c3d4",
+        taskType: "PrepareData",
+        codeHash: "e7f3a09b16c2d481",
+        configHash: "3bc1f84e927da056",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    raw_path = Path(self.config.input_dir)
+    df = pd.read_parquet(raw_path / "molecules.parquet")
+    if self.config.shuffle:
+        df = df.sample(frac=1, random_state=42)
+    train, test = train_test_split(df, test_size=0.2)
+    return {"train": train, "test": test}`,
+        snapshotKey: "e7f3a09b16c2d481:3bc1f84e927da056",
+        createdAt: "2026-02-12T14:00:00Z",
+        configData: { input_dir: "/data/raw", format: "parquet", shuffle: true },
+      },
+      {
+        taskId: "TrainModel_e5f6a7b8",
+        taskType: "TrainModel",
+        codeHash: "f91ab32c07d64e18",
+        configHash: "c5249e8b1fa07d63",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    train_data = inputs["train"]
+    model = GNNModel(version="v1")
+    optimizer = torch.optim.Adam(model.parameters(), lr=self.config.lr)
+    for epoch in range(self.config.epochs):
+        loss = train_epoch(model, train_data, optimizer, self.config.batch_size)
+        if epoch % 20 == 0:
+            logger.info(f"Epoch {epoch}: loss={loss:.4f}")
+    return {"model": model, "final_loss": loss}`,
+        snapshotKey: "f91ab32c07d64e18:c5249e8b1fa07d63",
+        createdAt: "2026-02-12T14:00:00Z",
+        configData: {
+          model: "gnn-v1",
+          epochs: 100,
+          lr: 0.001,
+          batch_size: 32,
+        },
+      },
+      {
+        taskId: "Evaluate_c9d0e1f2",
+        taskType: "Evaluate",
+        codeHash: "5b8d12ef6ca0793e",
+        configHash: "88c1d2e3f4a5b607",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    model = inputs["model"]
+    test_data = inputs["test"]
+    predictions = model.predict(test_data)
+    results = {}
+    for metric in self.config.metrics:
+        results[metric] = compute_metric(metric, test_data.y, predictions)
+    return {"metrics": results}`,
+        snapshotKey: "5b8d12ef6ca0793e:88c1d2e3f4a5b607",
+        createdAt: "2026-02-12T14:00:00Z",
+        configData: { metrics: ["mae", "rmse"], split: "test" },
+      },
+    ],
+  },
+  "run-003": {
+    runId: "run-003",
+    runLabel: "run-003 (baseline)",
+    createdAt: "2026-02-11T10:00:00Z",
+    snapshots: [
+      {
+        taskId: "PrepareData_a1b2c3d4",
+        taskType: "PrepareData",
+        codeHash: "e7f3a09b16c2d481",
+        configHash: "3bc1f84e927da056",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    raw_path = Path(self.config.input_dir)
+    df = pd.read_parquet(raw_path / "molecules.parquet")
+    if self.config.shuffle:
+        df = df.sample(frac=1, random_state=42)
+    train, test = train_test_split(df, test_size=0.2)
+    return {"train": train, "test": test}`,
+        snapshotKey: "e7f3a09b16c2d481:3bc1f84e927da056",
+        createdAt: "2026-02-11T10:00:00Z",
+        configData: { input_dir: "/data/raw", format: "parquet", shuffle: true },
+      },
+      {
+        taskId: "TrainModel_e5f6a7b8",
+        taskType: "TrainModel",
+        codeHash: "f91ab32c07d64e18",
+        configHash: "c5249e8b1fa07d63",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    train_data = inputs["train"]
+    model = GNNModel(version="v1")
+    optimizer = torch.optim.Adam(model.parameters(), lr=self.config.lr)
+    for epoch in range(self.config.epochs):
+        loss = train_epoch(model, train_data, optimizer, self.config.batch_size)
+        if epoch % 20 == 0:
+            logger.info(f"Epoch {epoch}: loss={loss:.4f}")
+    return {"model": model, "final_loss": loss}`,
+        snapshotKey: "f91ab32c07d64e18:c5249e8b1fa07d63",
+        createdAt: "2026-02-11T10:00:00Z",
+        configData: {
+          model: "gnn-v1",
+          epochs: 100,
+          lr: 0.001,
+          batch_size: 32,
+        },
+      },
+      {
+        taskId: "Evaluate_c9d0e1f2",
+        taskType: "Evaluate",
+        codeHash: "5b8d12ef6ca0793e",
+        configHash: "88c1d2e3f4a5b607",
+        codeSource: `def execute(self, inputs: dict) -> dict:
+    model = inputs["model"]
+    test_data = inputs["test"]
+    predictions = model.predict(test_data)
+    results = {}
+    for metric in self.config.metrics:
+        results[metric] = compute_metric(metric, test_data.y, predictions)
+    return {"metrics": results}`,
+        snapshotKey: "5b8d12ef6ca0793e:88c1d2e3f4a5b607",
+        createdAt: "2026-02-11T10:00:00Z",
+        configData: { metrics: ["mae", "rmse"], split: "test" },
+      },
+    ],
+  },
+};
+
+/** Look up mock snapshot set for a run. Falls back to empty. */
+export function getMockRunSnapshots(runId: string): RunSnapshotSet | null {
+  return MOCK_RUN_SNAPSHOTS[runId] ?? null;
+}
+
+/** All available mock run IDs (for the experiment-level selector). */
+export function getMockRunIds(): string[] {
+  return Object.keys(MOCK_RUN_SNAPSHOTS);
+}
+
+/** All mock run snapshot sets (for experiment diff). */
+export function getMockAllRunSnapshots(): RunSnapshotSet[] {
+  return Object.values(MOCK_RUN_SNAPSHOTS);
+}
+
+// ============================================================================
+// Diff computation
+// ============================================================================
+
+function computeDiff(
+  oldSnapshots: TaskSnapshotResponse[],
+  newSnapshots: TaskSnapshotResponse[],
+): TaskDiff[] {
+  const oldMap = new Map(oldSnapshots.map((s) => [s.taskId, s]));
+  const newMap = new Map(newSnapshots.map((s) => [s.taskId, s]));
+  const allIds = new Set([...oldMap.keys(), ...newMap.keys()]);
+
+  const diffs: TaskDiff[] = [];
+  for (const id of allIds) {
+    const oldSnap = oldMap.get(id) ?? null;
+    const newSnap = newMap.get(id) ?? null;
+
+    if (!oldSnap && newSnap) {
+      diffs.push({
+        taskId: id,
+        taskType: newSnap.taskType,
+        status: "added",
+        codeChanged: true,
+        configChanged: true,
+        oldSnapshot: null,
+        newSnapshot: newSnap,
+      });
+    } else if (oldSnap && !newSnap) {
+      diffs.push({
+        taskId: id,
+        taskType: oldSnap.taskType,
+        status: "removed",
+        codeChanged: true,
+        configChanged: true,
+        oldSnapshot: oldSnap,
+        newSnapshot: null,
+      });
+    } else if (oldSnap && newSnap) {
+      const codeChanged = oldSnap.codeHash !== newSnap.codeHash;
+      const configChanged = oldSnap.configHash !== newSnap.configHash;
+      diffs.push({
+        taskId: id,
+        taskType: newSnap.taskType,
+        status: codeChanged || configChanged ? "modified" : "unchanged",
+        codeChanged,
+        configChanged,
+        oldSnapshot: oldSnap,
+        newSnapshot: newSnap,
+      });
+    }
+  }
+
+  const order: Record<FieldStatus, number> = {
+    modified: 0,
+    added: 1,
+    removed: 2,
+    unchanged: 3,
+  };
+  diffs.sort((a, b) => order[a.status] - order[b.status]);
+  return diffs;
+}
+
+// ============================================================================
+// Shared sub-components
+// ============================================================================
+
+const StatusBadge = ({ status }: { status: FieldStatus }): JSX.Element => {
+  const styles: Record<FieldStatus, string> = {
+    unchanged: "bg-emerald-500/10 text-emerald-700 border-emerald-500/20",
+    modified: "bg-amber-500/10 text-amber-700 border-amber-500/20",
+    added: "bg-blue-500/10 text-blue-700 border-blue-500/20",
+    removed: "bg-red-500/10 text-red-700 border-red-500/20",
+  };
+  return (
+    <Badge variant="outline" className={`text-xs ${styles[status]}`}>
+      {status}
+    </Badge>
+  );
+};
+
+const ConfigValue = ({
+  label,
+  oldVal,
+  newVal,
+}: {
+  label: string;
+  oldVal: string | undefined;
+  newVal: string | undefined;
+}): JSX.Element | null => {
+  if (oldVal === undefined && newVal === undefined) return null;
+  const changed = oldVal !== newVal;
+  return (
+    <div className="flex items-start gap-2 text-xs leading-relaxed">
+      <span className="text-muted-foreground min-w-[100px] shrink-0">{label}</span>
+      {changed ? (
+        <span className="font-mono">
+          <span className="line-through text-red-500/70">{oldVal ?? "—"}</span>
+          <span className="mx-1.5 text-muted-foreground">&rarr;</span>
+          <span className="text-emerald-600 font-semibold">{newVal ?? "—"}</span>
+        </span>
+      ) : (
+        <span className="font-mono text-foreground">{newVal ?? "—"}</span>
+      )}
+    </div>
+  );
+};
+
+// ============================================================================
+// SnapshotCard — single task snapshot (used in RunSnapshotPanel)
+// ============================================================================
+
+export const SnapshotCard = ({ snapshot }: { snapshot: TaskSnapshotResponse }): JSX.Element => {
+  const [codeExpanded, setCodeExpanded] = useState(false);
+
+  return (
+    <div className="rounded-md border p-4 bg-card space-y-3">
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <Hash className="h-4 w-4 text-muted-foreground" />
+          <span className="font-mono text-sm font-medium">{snapshot.taskId}</span>
+        </div>
+        <Badge variant="outline" className="text-xs">
+          {snapshot.taskType}
+        </Badge>
+      </div>
+      <div className="grid grid-cols-2 gap-3 text-xs">
+        <div>
+          <p className="text-muted-foreground uppercase mb-1">Code Hash</p>
+          <p className="font-mono truncate" title={snapshot.codeHash}>
+            {snapshot.codeHash}
+          </p>
+        </div>
+        <div>
+          <p className="text-muted-foreground uppercase mb-1">Config Hash</p>
+          <p className="font-mono truncate" title={snapshot.configHash}>
+            {snapshot.configHash}
+          </p>
+        </div>
+        <div className="col-span-2">
+          <p className="text-muted-foreground uppercase mb-1">Snapshot Key</p>
+          <p className="font-mono text-xs truncate" title={snapshot.snapshotKey}>
+            {snapshot.snapshotKey}
+          </p>
+        </div>
+      </div>
+      {snapshot.configData && Object.keys(snapshot.configData).length > 0 && (
+        <div>
+          <p className="text-xs text-muted-foreground uppercase mb-1">Config</p>
+          <pre className="text-xs font-mono bg-muted/30 rounded p-2 overflow-x-auto max-h-32">
+            {JSON.stringify(snapshot.configData, null, 2)}
+          </pre>
+        </div>
+      )}
+      {snapshot.codeSource && (
+        <div>
+          <button
+            type="button"
+            className="flex items-center gap-1 text-xs text-muted-foreground uppercase mb-1 hover:text-foreground transition-colors cursor-pointer"
+            onClick={() => setCodeExpanded(!codeExpanded)}
+          >
+            {codeExpanded ? (
+              <ChevronDown className="h-3.5 w-3.5" />
+            ) : (
+              <ChevronRight className="h-3.5 w-3.5" />
+            )}
+            Source Code
+          </button>
+          {codeExpanded && (
+            <pre className="text-xs font-mono bg-slate-950 text-slate-50 rounded p-3 overflow-x-auto max-h-64">
+              {snapshot.codeSource}
+            </pre>
+          )}
+        </div>
+      )}
+    </div>
+  );
+};
+
+// ============================================================================
+// CodeDiffBlock — line-by-line code diff
+// ============================================================================
+
+interface DiffLine {
+  type: "same" | "added" | "removed";
+  text: string;
+}
+
+function computeLineDiff(oldCode: string, newCode: string): DiffLine[] {
+  const oldLines = oldCode.split("\n");
+  const newLines = newCode.split("\n");
+
+  // Simple LCS-based diff
+  const m = oldLines.length;
+  const n = newLines.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] =
+        oldLines[i - 1] === newLines[j - 1]
+          ? dp[i - 1][j - 1] + 1
+          : Math.max(dp[i - 1][j], dp[i][j - 1]);
+    }
+  }
+
+  const result: DiffLine[] = [];
+  let i = m,
+    j = n;
+  const stack: DiffLine[] = [];
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      stack.push({ type: "same", text: oldLines[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      stack.push({ type: "added", text: newLines[j - 1] });
+      j--;
+    } else {
+      stack.push({ type: "removed", text: oldLines[i - 1] });
+      i--;
+    }
+  }
+  stack.reverse();
+  result.push(...stack);
+  return result;
+}
+
+const CodeDiffBlock = ({ oldCode, newCode }: { oldCode: string; newCode: string }): JSX.Element => {
+  const lines = useMemo(() => computeLineDiff(oldCode, newCode), [oldCode, newCode]);
+
+  return (
+    <pre className="text-xs font-mono rounded overflow-x-auto max-h-72 bg-slate-950 p-3">
+      {lines.map((line) => {
+        const bgClass =
+          line.type === "removed"
+            ? "bg-red-500/15 text-red-300"
+            : line.type === "added"
+              ? "bg-emerald-500/15 text-emerald-300"
+              : "text-slate-400";
+        const prefix = line.type === "removed" ? "- " : line.type === "added" ? "+ " : "  ";
+        return (
+          <div
+            key={`diff-line-${line.type}-${line.text.slice(0, 40)}`}
+            className={`${bgClass} px-2 leading-relaxed`}
+          >
+            <span className="select-none opacity-50 mr-2">{prefix}</span>
+            {line.text}
+          </div>
+        );
+      })}
+    </pre>
+  );
+};
+
+// ============================================================================
+// DiffCard — single task diff (used in SnapshotDiffPanel)
+// ============================================================================
+
+const DiffCard = ({ diff }: { diff: TaskDiff }): JSX.Element => {
+  const oldCfg = diff.oldSnapshot?.configData ?? {};
+  const newCfg = diff.newSnapshot?.configData ?? {};
+  const allKeys = Array.from(new Set([...Object.keys(oldCfg), ...Object.keys(newCfg)]));
+
+  return (
+    <div className="rounded-md border p-4 bg-card space-y-3">
+      {/* Header */}
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <Hash className="h-4 w-4 text-muted-foreground" />
+          <span className="font-mono text-sm font-medium">{diff.taskId}</span>
+          <Badge variant="outline" className="text-xs">
+            {diff.taskType}
+          </Badge>
+        </div>
+        <StatusBadge status={diff.status} />
+      </div>
+
+      {/* Change indicators */}
+      {diff.status !== "unchanged" && (
+        <div className="flex items-center gap-3 text-xs">
+          <span
+            className={`flex items-center gap-1 ${
+              diff.codeChanged ? "text-amber-600" : "text-muted-foreground"
+            }`}
+          >
+            <Code className="h-3.5 w-3.5" />
+            code {diff.codeChanged ? "changed" : "same"}
+          </span>
+          <span
+            className={`flex items-center gap-1 ${
+              diff.configChanged ? "text-amber-600" : "text-muted-foreground"
+            }`}
+          >
+            <Settings className="h-3.5 w-3.5" />
+            config {diff.configChanged ? "changed" : "same"}
+          </span>
+        </div>
+      )}
+
+      {/* Hash diff */}
+      {diff.status === "modified" && (
+        <div className="grid grid-cols-2 gap-3 text-xs">
+          <div>
+            <p className="text-muted-foreground uppercase mb-1">Code Hash</p>
+            <p className="font-mono">
+              {diff.codeChanged ? (
+                <>
+                  <span className="line-through text-red-500/70">{diff.oldSnapshot?.codeHash}</span>
+                  <br />
+                  <span className="text-emerald-600 font-semibold">
+                    {diff.newSnapshot?.codeHash}
+                  </span>
+                </>
+              ) : (
+                <span>{diff.newSnapshot?.codeHash}</span>
+              )}
+            </p>
+          </div>
+          <div>
+            <p className="text-muted-foreground uppercase mb-1">Config Hash</p>
+            <p className="font-mono">
+              {diff.configChanged ? (
+                <>
+                  <span className="line-through text-red-500/70">
+                    {diff.oldSnapshot?.configHash}
+                  </span>
+                  <br />
+                  <span className="text-emerald-600 font-semibold">
+                    {diff.newSnapshot?.configHash}
+                  </span>
+                </>
+              ) : (
+                <span>{diff.newSnapshot?.configHash}</span>
+              )}
+            </p>
+          </div>
+        </div>
+      )}
+
+      {/* Config field-level diff */}
+      {diff.status === "modified" && diff.configChanged && allKeys.length > 0 && (
+        <div className="border-t pt-3 space-y-1.5">
+          <p className="text-xs text-muted-foreground uppercase mb-2">Config Diff</p>
+          {allKeys.map((key) => (
+            <ConfigValue
+              key={key}
+              label={key}
+              oldVal={oldCfg[key] !== undefined ? JSON.stringify(oldCfg[key]) : undefined}
+              newVal={newCfg[key] !== undefined ? JSON.stringify(newCfg[key]) : undefined}
+            />
+          ))}
+        </div>
+      )}
+
+      {/* Code diff */}
+      {diff.status === "modified" &&
+        diff.codeChanged &&
+        diff.oldSnapshot?.codeSource &&
+        diff.newSnapshot?.codeSource && (
+          <div className="border-t pt-3">
+            <p className="text-xs text-muted-foreground uppercase mb-2">Code Diff</p>
+            <CodeDiffBlock
+              oldCode={diff.oldSnapshot.codeSource}
+              newCode={diff.newSnapshot.codeSource}
+            />
+          </div>
+        )}
+
+      {/* Added task */}
+      {diff.status === "added" && diff.newSnapshot?.configData && (
+        <div>
+          <p className="text-xs text-muted-foreground uppercase mb-1">Config (new)</p>
+          <pre className="text-xs font-mono bg-emerald-500/5 border border-emerald-500/20 rounded p-2 overflow-x-auto max-h-32">
+            {JSON.stringify(diff.newSnapshot.configData, null, 2)}
+          </pre>
+        </div>
+      )}
+      {diff.status === "added" && diff.newSnapshot?.codeSource && (
+        <div>
+          <p className="text-xs text-muted-foreground uppercase mb-1">Source Code (new)</p>
+          <pre className="text-xs font-mono bg-emerald-500/5 border border-emerald-500/20 rounded p-3 overflow-x-auto max-h-48 text-emerald-800">
+            {diff.newSnapshot.codeSource}
+          </pre>
+        </div>
+      )}
+
+      {/* Removed task */}
+      {diff.status === "removed" && diff.oldSnapshot?.configData && (
+        <div>
+          <p className="text-xs text-muted-foreground uppercase mb-1">Config (removed)</p>
+          <pre className="text-xs font-mono bg-red-500/5 border border-red-500/20 rounded p-2 overflow-x-auto max-h-32 line-through">
+            {JSON.stringify(diff.oldSnapshot.configData, null, 2)}
+          </pre>
+        </div>
+      )}
+      {diff.status === "removed" && diff.oldSnapshot?.codeSource && (
+        <div>
+          <p className="text-xs text-muted-foreground uppercase mb-1">Source Code (removed)</p>
+          <pre className="text-xs font-mono bg-red-500/5 border border-red-500/20 rounded p-3 overflow-x-auto max-h-48 line-through text-red-800">
+            {diff.oldSnapshot.codeSource}
+          </pre>
+        </div>
+      )}
+
+      {/* Unchanged */}
+      {diff.status === "unchanged" && (
+        <p className="text-xs text-muted-foreground italic">
+          No changes — snapshot key{" "}
+          <span className="font-mono">{diff.newSnapshot?.snapshotKey}</span>
+        </p>
+      )}
+    </div>
+  );
+};
+
+// ============================================================================
+// DiffSummaryBar
+// ============================================================================
+
+const DiffSummaryBar = ({ diffs }: { diffs: TaskDiff[] }): JSX.Element => {
+  const counts = useMemo(() => {
+    const c = { unchanged: 0, modified: 0, added: 0, removed: 0 };
+    for (const d of diffs) c[d.status]++;
+    return c;
+  }, [diffs]);
+
+  return (
+    <div className="flex items-center gap-4 text-xs">
+      {counts.modified > 0 && (
+        <span className="flex items-center gap-1 text-amber-600">
+          <AlertCircle className="h-3.5 w-3.5" />
+          {counts.modified} modified
+        </span>
+      )}
+      {counts.added > 0 && (
+        <span className="flex items-center gap-1 text-blue-600">+ {counts.added} added</span>
+      )}
+      {counts.removed > 0 && (
+        <span className="flex items-center gap-1 text-red-600">- {counts.removed} removed</span>
+      )}
+      {counts.unchanged > 0 && (
+        <span className="flex items-center gap-1 text-emerald-600">
+          <CheckCircle2 className="h-3.5 w-3.5" />
+          {counts.unchanged} unchanged
+        </span>
+      )}
+    </div>
+  );
+};
+
+// ============================================================================
+// RunSnapshotPanel — for RunViewer "Snapshot" tab
+// ============================================================================
+
+/**
+ * Displays the fixed snapshot set for a single run.
+ * This is read-only — a run's snapshot is immutable.
+ */
+export const RunSnapshotPanel = ({ runId }: { runId: string }): JSX.Element => {
+  // In production: fetch from API.  For now: mock data.
+  const snapshotSet = getMockRunSnapshots(runId);
+
+  if (!snapshotSet) {
+    return (
+      <div className="flex flex-col items-center justify-center h-full gap-3 text-muted-foreground">
+        <Database className="h-10 w-10 opacity-20" />
+        <p className="text-sm">No snapshot recorded for this run.</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex h-full flex-col overflow-y-auto">
+      <div className="px-6 py-4 border-b bg-background flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <Hash className="h-4 w-4 text-muted-foreground" />
+          <span className="text-sm font-medium">
+            Task Snapshots
+            <span className="text-muted-foreground font-normal ml-1">
+              ({snapshotSet.snapshots.length})
+            </span>
+          </span>
+        </div>
+        <span className="text-xs text-muted-foreground font-mono">
+          {new Date(snapshotSet.createdAt).toLocaleString()}
+        </span>
+      </div>
+      <div className="flex-1 p-6 space-y-3">
+        {snapshotSet.snapshots.map((snap) => (
+          <SnapshotCard key={snap.taskId} snapshot={snap} />
+        ))}
+      </div>
+    </div>
+  );
+};
+
+// ============================================================================
+// SnapshotDiffPanel — for ExperimentViewer "Diff" tab
+// ============================================================================
+
+/**
+ * Lets the user pick two runs and shows a field-level diff of their snapshots.
+ */
+export const SnapshotDiffPanel = ({
+  experimentRunIds,
+}: {
+  experimentRunIds: string[];
+}): JSX.Element => {
+  const allSets = getMockAllRunSnapshots();
+  // Filter to runs that belong to this experiment (mock: use all available)
+  const availableSets = allSets.filter(
+    (s) => experimentRunIds.length === 0 || experimentRunIds.includes(s.runId),
+  );
+
+  const [baseId, setBaseId] = useState<string>(availableSets[1]?.runId ?? "");
+  const [targetId, setTargetId] = useState<string>(availableSets[0]?.runId ?? "");
+
+  const baseSet = availableSets.find((s) => s.runId === baseId);
+  const targetSet = availableSets.find((s) => s.runId === targetId);
+
+  const diffs = useMemo(() => {
+    if (!baseSet || !targetSet) return [];
+    return computeDiff(baseSet.snapshots, targetSet.snapshots);
+  }, [baseSet, targetSet]);
+
+  const ready = baseSet && targetSet && baseId !== targetId;
+
+  return (
+    <div className="flex h-full flex-col overflow-y-auto">
+      {/* Run selector */}
+      <div className="px-6 py-4 border-b bg-background">
+        <div className="flex items-center gap-3 flex-wrap">
+          <div className="flex items-center gap-2">
+            <GitCompareArrows className="h-4 w-4 text-muted-foreground" />
+            <span className="text-sm font-medium">Compare</span>
+          </div>
+
+          <Select value={baseId} onValueChange={setBaseId}>
+            <SelectTrigger size="sm">
+              <SelectValue placeholder="Base run" />
+            </SelectTrigger>
+            <SelectContent>
+              {availableSets.map((s) => (
+                <SelectItem key={s.runId} value={s.runId}>
+                  {s.runLabel}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+
+          <span className="text-muted-foreground text-sm">&rarr;</span>
+
+          <Select value={targetId} onValueChange={setTargetId}>
+            <SelectTrigger size="sm">
+              <SelectValue placeholder="Target run" />
+            </SelectTrigger>
+            <SelectContent>
+              {availableSets.map((s) => (
+                <SelectItem key={s.runId} value={s.runId}>
+                  {s.runLabel}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+
+          {ready && <DiffSummaryBar diffs={diffs} />}
+        </div>
+        {baseId === targetId && baseId !== "" && (
+          <p className="text-xs text-amber-600 mt-2">
+            Base and target are the same run — select different runs to see a diff.
+          </p>
+        )}
+      </div>
+
+      {/* Diff cards */}
+      <div className="flex-1 p-6 space-y-3">
+        {!ready ? (
+          <div className="flex flex-col items-center justify-center h-full gap-3 text-muted-foreground">
+            <GitCompareArrows className="h-10 w-10 opacity-20" />
+            <p className="text-sm">Select two different runs to compare their snapshots.</p>
+          </div>
+        ) : diffs.length === 0 ? (
+          <p className="text-sm text-muted-foreground">No tasks to compare.</p>
+        ) : (
+          diffs.map((diff) => <DiffCard key={diff.taskId} diff={diff} />)
+        )}
+      </div>
+    </div>
+  );
+};
diff --git a/ui/src/app/renderers/TabbedViewer.tsx b/ui/src/app/renderers/TabbedViewer.tsx
index 05214beb..1c004c43 100644
--- a/ui/src/app/renderers/TabbedViewer.tsx
+++ b/ui/src/app/renderers/TabbedViewer.tsx
@@ -1,7 +1,7 @@
 import { useState } from "react";
-import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import type { RendererProps } from "@/app/types";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 
 interface ViewTab {
   id: string;
@@ -52,11 +52,7 @@ export const TabbedViewer = ({
         </CardHeader>
       )}
       <CardContent className="flex-1 flex flex-col p-0">
-        <Tabs
-          value={activeTab}
-          onValueChange={setActiveTab}
-          className="flex-1 flex flex-col"
-        >
+        <Tabs value={activeTab} onValueChange={setActiveTab} className="flex-1 flex flex-col">
           <TabsList className="mx-4 mt-4 w-fit">
             {tabs.map((tab) => (
               <TabsTrigger key={tab.id} value={tab.id}>
diff --git a/ui/src/app/renderers/TextEditor.tsx b/ui/src/app/renderers/TextEditor.tsx
index 7d86b6bc..7cf79234 100644
--- a/ui/src/app/renderers/TextEditor.tsx
+++ b/ui/src/app/renderers/TextEditor.tsx
@@ -1,16 +1,26 @@
-import { useEffect, useMemo, useState } from "react";
 import Editor from "@monaco-editor/react";
 import { Save } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import { workspaceApi } from "@/app/state/api";
+import type { RendererProps } from "@/app/types";
+import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Separator } from "@/components/ui/separator";
-import { Button } from "@/components/ui/button";
-import type { RendererProps } from "@/app/types";
-import { workspaceApi } from "@/app/state/api";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { filePreviewPluginRegistry } from "@/lib/file-preview-plugins";
 
 export const TextEditor = ({ selection }: RendererProps): JSX.Element => {
   const [value, setValue] = useState<string>("");
   const [status, setStatus] = useState<"idle" | "loading" | "saving" | "error">("idle");
   const [error, setError] = useState<string | null>(null);
+  const previewPlugin = useMemo(() => {
+    if (selection.objectType !== "workspace-file") {
+      return null;
+    }
+
+    const name = selection.filePath.split("/").pop() ?? selection.filePath;
+    return filePreviewPluginRegistry.getPluginForFile(name, selection.filePath);
+  }, [selection]);
 
   const language = useMemo(() => {
     // If not a file, default to text. Though logic suggests it handles files usually.
@@ -52,13 +62,15 @@ export const TextEditor = ({ selection }: RendererProps): JSX.Element => {
           setStatus("error");
         }
       });
-      
-    return () => { isMounted = false; };
+
+    return () => {
+      isMounted = false;
+    };
   }, [selection]); // Re-fetch when selection changes
 
   const handleSave = async () => {
     if (selection.objectType !== "workspace-file") return;
-    
+
     setStatus("saving");
     try {
       await workspaceApi.writeFile(selection.objectId, value);
@@ -73,15 +85,13 @@ export const TextEditor = ({ selection }: RendererProps): JSX.Element => {
     <Card className="flex h-full flex-col border-border/60 bg-background">
       <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
         <div className="space-y-1">
-           <CardTitle className="text-lg font-semibold">Text Editor</CardTitle>
-           <p className="text-sm text-muted-foreground break-all">
-             {selection.objectId}
-           </p>
+          <CardTitle className="text-lg font-semibold">Text Editor</CardTitle>
+          <p className="text-sm text-muted-foreground break-all">{selection.objectId}</p>
         </div>
-        <Button 
-          variant="outline" 
-          size="sm" 
-          onClick={handleSave} 
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={handleSave}
           disabled={status === "loading" || status === "saving"}
           className="gap-2"
         >
@@ -90,25 +100,48 @@ export const TextEditor = ({ selection }: RendererProps): JSX.Element => {
         </Button>
       </CardHeader>
       <Separator />
-      <CardContent className="flex-1 pt-4 p-0 min-h-0"> 
-        {/* Adjusted padding/overflow for editor */}
+      <CardContent className="flex-1 pt-4 p-0 min-h-0">
         {status === "error" ? (
           <div className="p-4 text-sm text-destructive">{error}</div>
         ) : (
-          <Editor
-            height="100%"
-            language={language}
-            value={value}
-            theme="light" // or check system theme
-            onChange={(nextValue) => {
-              setValue(nextValue ?? "");
-            }}
-            options={{
-              minimap: { enabled: false },
-              wordWrap: "on",
-              scrollBeyondLastLine: false,
-            }}
-          />
+          <Tabs defaultValue="edit" className="flex h-full flex-col">
+            {previewPlugin ? (
+              <div className="border-b border-border/60 px-4 py-2">
+                <TabsList className="h-auto w-fit rounded-md bg-muted/30 p-1">
+                  <TabsTrigger value="edit">Edit</TabsTrigger>
+                  <TabsTrigger value="preview">Preview</TabsTrigger>
+                </TabsList>
+              </div>
+            ) : null}
+
+            <TabsContent value="edit" className="m-0 flex-1 min-h-0">
+              <Editor
+                height="100%"
+                language={language}
+                value={value}
+                theme="light"
+                onChange={(nextValue) => {
+                  setValue(nextValue ?? "");
+                }}
+                options={{
+                  minimap: { enabled: false },
+                  wordWrap: "on",
+                  scrollBeyondLastLine: false,
+                }}
+              />
+            </TabsContent>
+
+            {previewPlugin && selection.objectType === "workspace-file" ? (
+              <TabsContent value="preview" className="m-0 flex-1 overflow-auto">
+                <previewPlugin.Component
+                  content={value}
+                  name={selection.filePath.split("/").pop() ?? selection.filePath}
+                  path={selection.filePath}
+                  folderId="workspace"
+                />
+              </TabsContent>
+            ) : null}
+          </Tabs>
         )}
       </CardContent>
     </Card>
diff --git a/ui/src/app/renderers/WorkflowFileViewer.tsx b/ui/src/app/renderers/WorkflowFileViewer.tsx
index 4e4bbc75..547d439f 100644
--- a/ui/src/app/renderers/WorkflowFileViewer.tsx
+++ b/ui/src/app/renderers/WorkflowFileViewer.tsx
@@ -1,18 +1,18 @@
-import { useEffect, useMemo, useState } from "react";
-import type { Edge, Node, NodeProps } from "@xyflow/react";
+import type { Edge, Node, NodeProps, NodeTypes } from "@xyflow/react";
 import {
   Background,
-  Controls,
   ControlButton,
+  Controls,
   MarkerType,
   Position,
   ReactFlow,
 } from "@xyflow/react";
+import { useEffect, useMemo, useState } from "react";
 import "@xyflow/react/dist/style.css";
+import { workspaceApi } from "@/app/state/api";
+import type { RendererProps, SemanticStatus } from "@/app/types";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Separator } from "@/components/ui/separator";
-import type { RendererProps, SemanticStatus } from "@/app/types";
-import { workspaceApi } from "@/app/state/api";
 
 interface WorkflowFileNode {
   task_id: string;
@@ -34,13 +34,15 @@ interface WorkflowFilePayload {
   links: WorkflowFileLink[];
 }
 
-interface WorkflowNodeData {
+interface WorkflowNodeData extends Record<string, unknown> {
   label: string;
   nodeType: "task";
   status: SemanticStatus;
   description: string;
 }
 
+type WorkflowFlowNode = Node<WorkflowNodeData, "workflowNode">;
+
 const statusStyles: Record<SemanticStatus, { border: string; background: string; edge: string }> = {
   active: { border: "#10b981", background: "#ecfdf5", edge: "#10b981" },
   archived: { border: "#64748b", background: "#f1f5f9", edge: "#64748b" },
@@ -50,9 +52,10 @@ const statusStyles: Record<SemanticStatus, { border: string; background: string;
   succeeded: { border: "#16a34a", background: "#f0fdf4", edge: "#16a34a" },
   failed: { border: "#ef4444", background: "#fef2f2", edge: "#ef4444" },
   cancelled: { border: "#6b7280", background: "#f3f4f6", edge: "#6b7280" },
+  skipped: { border: "#d97706", background: "#fffbeb", edge: "#d97706" },
 };
 
-const WorkflowNode = ({ data }: NodeProps<WorkflowNodeData>): JSX.Element => {
+const WorkflowNode = ({ data }: NodeProps<WorkflowFlowNode>): JSX.Element => {
   const style = statusStyles[data.status] ?? statusStyles.pending;
   return (
     <div
@@ -68,23 +71,19 @@ const WorkflowNode = ({ data }: NodeProps<WorkflowNodeData>): JSX.Element => {
   );
 };
 
-const layoutNodes = (
-  tasks: WorkflowFileNode[],
-  links: WorkflowFileLink[],
-): Array<Node<WorkflowNodeData>> => {
+const layoutNodes = (tasks: WorkflowFileNode[], links: WorkflowFileLink[]): WorkflowFlowNode[] => {
   const columnWidth = 260;
   const rowHeight = 150;
 
-  const taskById = new Map(tasks.map(task => [task.task_id, task]));
   const inDegree = new Map<string, number>();
   const adjacency = new Map<string, string[]>();
 
-  tasks.forEach(task => {
+  tasks.forEach((task) => {
     inDegree.set(task.task_id, 0);
     adjacency.set(task.task_id, []);
   });
 
-  links.forEach(link => {
+  links.forEach((link) => {
     if (!adjacency.has(link.source)) {
       adjacency.set(link.source, []);
     }
@@ -93,10 +92,12 @@ const layoutNodes = (
   });
 
   const queue = tasks
-    .filter(task => (inDegree.get(task.task_id) ?? 0) === 0)
-    .map(task => task.task_id);
+    .filter((task) => (inDegree.get(task.task_id) ?? 0) === 0)
+    .map((task) => task.task_id);
   const levels = new Map<string, number>();
-  queue.forEach(id => levels.set(id, 0));
+  for (const id of queue) {
+    levels.set(id, 0);
+  }
 
   while (queue.length > 0) {
     const current = queue.shift();
@@ -115,7 +116,7 @@ const layoutNodes = (
   }
 
   const layers = new Map<number, WorkflowFileNode[]>();
-  tasks.forEach(task => {
+  tasks.forEach((task) => {
     const level = levels.get(task.task_id) ?? 0;
     const layer = layers.get(level) ?? [];
     layer.push(task);
@@ -144,7 +145,7 @@ const layoutNodes = (
 export const WorkflowFileViewer = ({ selection }: RendererProps): JSX.Element => {
   const [payload, setPayload] = useState<WorkflowFilePayload | null>(null);
   const [error, setError] = useState<string | null>(null);
-  const [layoutVersion, setLayoutVersion] = useState(0);
+  const [_layoutVersion, setLayoutVersion] = useState(0);
   const [reactFlowInstance, setReactFlowInstance] = useState<{
     fitView: () => void;
   } | null>(null);
@@ -156,38 +157,38 @@ export const WorkflowFileViewer = ({ selection }: RendererProps): JSX.Element =>
 
     workspaceApi
       .getWorkspaceFileText(selection.objectId)
-      .then(content => {
+      .then((content) => {
         const parsed = JSON.parse(content) as WorkflowFilePayload;
         if (!parsed.task_configs || !parsed.links) {
           throw new Error("Invalid workflow.json payload");
         }
-        const missingTaskStatus = parsed.task_configs.some(task => !task.status);
-        const missingLinkStatus = parsed.links.some(link => !link.status);
+        const missingTaskStatus = parsed.task_configs.some((task) => !task.status);
+        const missingLinkStatus = parsed.links.some((link) => !link.status);
         if (missingTaskStatus || missingLinkStatus) {
           throw new Error("workflow.json is missing status fields for nodes or links");
         }
         setPayload(parsed);
         setError(null);
-        setLayoutVersion(prev => prev + 1);
+        setLayoutVersion((prev) => prev + 1);
       })
-      .catch(err => {
+      .catch((err) => {
         setError(err instanceof Error ? err.message : "Failed to load workflow");
         setPayload(null);
       });
   }, [selection]);
 
-  const nodes = useMemo<Array<Node<WorkflowNodeData>>>(() => {
+  const nodes = useMemo<WorkflowFlowNode[]>(() => {
     if (!payload) {
       return [];
     }
     return layoutNodes(payload.task_configs, payload.links);
-  }, [payload, layoutVersion]);
+  }, [payload]);
 
   const edges = useMemo<Array<Edge>>(() => {
     if (!payload) {
       return [];
     }
-    return payload.links.map(link => {
+    return payload.links.map((link) => {
       const style = statusStyles[link.status] ?? statusStyles.pending;
       return {
         id: `${link.source}:${link.target}`,
@@ -203,10 +204,7 @@ export const WorkflowFileViewer = ({ selection }: RendererProps): JSX.Element =>
     });
   }, [payload]);
 
-  const nodeTypes = useMemo<Record<string, (props: NodeProps<WorkflowNodeData>) => JSX.Element>>(
-    () => ({ workflowNode: WorkflowNode }),
-    [],
-  );
+  const nodeTypes = useMemo<NodeTypes>(() => ({ workflowNode: WorkflowNode }), []);
 
   return (
     <Card className="flex h-full flex-col border-border/60 bg-background">
@@ -227,7 +225,7 @@ export const WorkflowFileViewer = ({ selection }: RendererProps): JSX.Element =>
               nodeTypes={nodeTypes}
               fitView
               className="flex-1"
-              onInit={instance => {
+              onInit={(instance) => {
                 setReactFlowInstance(instance);
               }}
             >
@@ -235,7 +233,7 @@ export const WorkflowFileViewer = ({ selection }: RendererProps): JSX.Element =>
               <Controls>
                 <ControlButton
                   onClick={() => {
-                    setLayoutVersion(prev => prev + 1);
+                    setLayoutVersion((prev) => prev + 1);
                     reactFlowInstance?.fitView();
                   }}
                   title="Refresh layout"
diff --git a/ui/src/app/renderers/WorkflowGraphViewer.tsx b/ui/src/app/renderers/WorkflowGraphViewer.tsx
index 57ab50f6..6adf91d4 100644
--- a/ui/src/app/renderers/WorkflowGraphViewer.tsx
+++ b/ui/src/app/renderers/WorkflowGraphViewer.tsx
@@ -1,11 +1,16 @@
+import type { Edge, Node, NodeProps, NodeTypes } from "@xyflow/react";
+import { Background, Controls, Handle, MarkerType, Position, ReactFlow } from "@xyflow/react";
 import { useEffect, useMemo, useState } from "react";
-import type { Node, Edge, NodeProps } from "@xyflow/react";
-import { ReactFlow, Background, Controls, Handle, Position, MarkerType } from "@xyflow/react";
 import "@xyflow/react/dist/style.css";
+import type {
+  RendererProps,
+  SemanticStatus,
+  WorkflowGraph,
+  WorkflowNodeMetadata,
+} from "@/app/types";
 import { Badge } from "@/components/ui/badge";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Skeleton } from "@/components/ui/skeleton";
-import type { RendererProps, SemanticStatus } from "@/app/types";
 
 interface WorkflowNodeData extends Record<string, unknown> {
   label: string;
@@ -14,232 +19,574 @@ interface WorkflowNodeData extends Record<string, unknown> {
   description: string;
 }
 
+interface WorkflowEdgeWithStatus {
+  id: string;
+  source: string;
+  target: string;
+  label: string;
+  status: SemanticStatus;
+  animated?: boolean;
+}
+
+interface DisplayWorkflowGraph {
+  nodes: WorkflowNodeMetadata[];
+  edges: WorkflowEdgeWithStatus[];
+}
+
+interface FileWorkflowData {
+  id: string;
+  name?: string;
+  graph: DisplayWorkflowGraph | null;
+}
+
+type WorkflowFlowNode = Node<WorkflowNodeData, "workflowNode">;
+
+const STATUS_VALUES: readonly SemanticStatus[] = [
+  "active",
+  "archived",
+  "draft",
+  "pending",
+  "running",
+  "succeeded",
+  "failed",
+  "cancelled",
+  "skipped",
+];
+
+const getSemanticStatus = (value: unknown): SemanticStatus => {
+  if (typeof value === "string" && STATUS_VALUES.includes(value as SemanticStatus)) {
+    return value as SemanticStatus;
+  }
+  return "pending";
+};
+
+const asRecord = (value: unknown): Record<string, unknown> | null => {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return null;
+};
+
 const getStatusColor = (status: SemanticStatus): string => {
   switch (status) {
-    case "succeeded": return "border-blue-500 text-blue-700"; // Blue
-    case "failed": return "border-red-500 text-red-700"; // Red
-    case "running": return "border-green-500 text-green-700"; // Green
-    case "skipped": return "border-yellow-500 text-yellow-700"; // Yellow
-    case "cancelled": return "border-yellow-500 text-yellow-700"; // Yellow
-    default: return "border-border text-foreground";
+    case "succeeded":
+      return "border-blue-500 text-blue-700";
+    case "failed":
+      return "border-red-500 text-red-700";
+    case "running":
+      return "border-green-500 text-green-700";
+    case "skipped":
+    case "cancelled":
+      return "border-yellow-500 text-yellow-700";
+    default:
+      return "border-border text-foreground";
   }
 };
 
 const getEdgeColor = (status: SemanticStatus): string => {
   switch (status) {
-    case "succeeded": return "#3b82f6"; // blue-500
-    case "failed": return "#ef4444"; // red-500
-    case "running": return "#22c55e"; // green-500
-    case "skipped": return "#eab308"; // yellow-500
-    case "cancelled": return "#eab308"; // yellow-500
-    default: return "#94a3b8"; // slate-400
+    case "succeeded":
+      return "#3b82f6";
+    case "failed":
+      return "#ef4444";
+    case "running":
+      return "#22c55e";
+    case "skipped":
+    case "cancelled":
+      return "#eab308";
+    default:
+      return "#94a3b8";
   }
 };
 
-const WorkflowNode = ({ data }: NodeProps<WorkflowNodeData>): JSX.Element => {
+const WorkflowNode = ({ data }: NodeProps<WorkflowFlowNode>): JSX.Element => {
   const colorClass = getStatusColor(data.status);
-  
+
   return (
-    <div className={`rounded-md border-2 bg-background px-3 py-2 shadow-sm min-w-[150px] ${colorClass}`}>
-      <Handle type="target" position={Position.Top} className="w-3 h-3 bg-muted-foreground" />
-      <p className="text-xs font-semibold uppercase tracking-wide opacity-70">
-        {data.nodeType}
-      </p>
+    <div
+      className={`rounded-md border-2 bg-background px-3 py-2 shadow-sm min-w-[150px] ${colorClass}`}
+    >
+      <Handle type="target" position={Position.Top} className="h-3 w-3 bg-muted-foreground" />
+      <p className="text-xs font-semibold uppercase tracking-wide opacity-70">{data.nodeType}</p>
       <p className="text-sm font-bold">{data.label}</p>
       <p className="text-xs opacity-70 capitalize">{data.status}</p>
-      <Handle type="source" position={Position.Bottom} className="w-3 h-3 bg-muted-foreground" />
+      <Handle type="source" position={Position.Bottom} className="h-3 w-3 bg-muted-foreground" />
     </div>
   );
 };
 
-/**
- * Extract workflow data from run.json or ckpt.json
- */
-const extractWorkflowFromFile = async (filePath: string): Promise<any | null> => {
+const normalizeGraph = (graph: WorkflowGraph): DisplayWorkflowGraph => {
+  return {
+    nodes: graph.nodes.map((node) => ({
+      nodeId: node.nodeId,
+      label: node.label,
+      nodeType: node.nodeType,
+      status: node.status,
+      description: node.description,
+      position: node.position,
+    })),
+    edges: graph.edges.map((edge) => ({
+      id: edge.id,
+      source: edge.source,
+      target: edge.target,
+      label: edge.label,
+      status: "pending",
+    })),
+  };
+};
+
+const normalizeGraphFromUnknown = (value: unknown): DisplayWorkflowGraph | null => {
+  const graph = asRecord(value);
+  if (!graph) {
+    return null;
+  }
+
+  const rawNodes = Array.isArray(graph.nodes) ? graph.nodes : null;
+  if (!rawNodes) {
+    return null;
+  }
+
+  const nodes: WorkflowNodeMetadata[] = rawNodes
+    .map((item) => {
+      const node = asRecord(item);
+      if (!node) {
+        return null;
+      }
+      const nodeId = typeof node.nodeId === "string" ? node.nodeId : null;
+      if (!nodeId) {
+        return null;
+      }
+
+      const nodeType =
+        node.nodeType === "task" || node.nodeType === "input" || node.nodeType === "output"
+          ? node.nodeType
+          : "task";
+      const positionRecord = asRecord(node.position);
+      const x = typeof positionRecord?.x === "number" ? positionRecord.x : 0;
+      const y = typeof positionRecord?.y === "number" ? positionRecord.y : 0;
+
+      return {
+        nodeId,
+        label: typeof node.label === "string" ? node.label : nodeId,
+        nodeType,
+        status: getSemanticStatus(node.status),
+        description: typeof node.description === "string" ? node.description : "",
+        position: { x, y },
+      };
+    })
+    .filter((node): node is WorkflowNodeMetadata => node !== null);
+
+  const rawEdges = Array.isArray(graph.edges) ? graph.edges : [];
+  const edges: WorkflowEdgeWithStatus[] = rawEdges.reduce<WorkflowEdgeWithStatus[]>(
+    (acc, item, index) => {
+      const edge = asRecord(item);
+      if (!edge || typeof edge.source !== "string" || typeof edge.target !== "string") {
+        return acc;
+      }
+      acc.push({
+        id: typeof edge.id === "string" ? edge.id : `edge-${index}`,
+        source: edge.source,
+        target: edge.target,
+        label: typeof edge.label === "string" ? edge.label : "",
+        status: getSemanticStatus(edge.status),
+        animated: edge.animated === true,
+      });
+      return acc;
+    },
+    [],
+  );
+
+  return { nodes, edges };
+};
+
+const graphFromTaskConfigPayload = (
+  value: Record<string, unknown>,
+): DisplayWorkflowGraph | null => {
+  const tasks = Array.isArray(value.task_configs) ? value.task_configs : null;
+  const links = Array.isArray(value.links) ? value.links : null;
+  if (!tasks || !links) {
+    return null;
+  }
+
+  const nodes: WorkflowNodeMetadata[] = tasks
+    .map((item, index) => {
+      const task = asRecord(item);
+      if (!task || typeof task.task_id !== "string") {
+        return null;
+      }
+
+      return {
+        nodeId: task.task_id,
+        label: typeof task.task_type === "string" ? task.task_type : task.task_id,
+        nodeType: "task",
+        status: getSemanticStatus(task.status),
+        description: task.task_id,
+        position: { x: (index % 4) * 220, y: Math.floor(index / 4) * 140 },
+      };
+    })
+    .filter((node): node is WorkflowNodeMetadata => node !== null);
+
+  const edges: WorkflowEdgeWithStatus[] = links.reduce<WorkflowEdgeWithStatus[]>(
+    (acc, item, index) => {
+      const link = asRecord(item);
+      if (!link || typeof link.source !== "string" || typeof link.target !== "string") {
+        return acc;
+      }
+      acc.push({
+        id: typeof link.id === "string" ? link.id : `${link.source}:${link.target}:${index}`,
+        source: link.source,
+        target: link.target,
+        label: typeof link.label === "string" ? link.label : "",
+        status: getSemanticStatus(link.status),
+        animated: link.animated === true,
+      });
+      return acc;
+    },
+    [],
+  );
+
+  return { nodes, edges };
+};
+
+const extractWorkflowFromFile = async (filePath: string): Promise<FileWorkflowData | null> => {
   try {
     const response = await fetch(`/api/workspace/files?path=${encodeURIComponent(filePath)}`);
-    if (!response.ok) return null;
-    
-    const data = await response.json();
-    
-    // Check if this is run.json or ckpt.json with context.workflow
-    if (data.context?.workflow) {
-      return data.context.workflow;
+    if (!response.ok) {
+      return null;
     }
-    
-    // Check if this is a direct workflow file
-    if (data.task_configs && data.links) {
-      return data;
+
+    const data = (await response.json()) as unknown;
+    const root = asRecord(data);
+    if (!root) {
+      return null;
     }
-    
-    return null;
+
+    const context = asRecord(root.context);
+    const contextWorkflow = asRecord(context?.workflow);
+    if (contextWorkflow) {
+      return {
+        id:
+          typeof contextWorkflow.workflow_id === "string"
+            ? contextWorkflow.workflow_id
+            : typeof contextWorkflow.id === "string"
+              ? contextWorkflow.id
+              : filePath,
+        name: typeof contextWorkflow.name === "string" ? contextWorkflow.name : undefined,
+        graph:
+          normalizeGraphFromUnknown(contextWorkflow.graph) ??
+          graphFromTaskConfigPayload(contextWorkflow),
+      };
+    }
+
+    return {
+      id: typeof root.workflow_id === "string" ? root.workflow_id : filePath,
+      name: typeof root.name === "string" ? root.name : undefined,
+      graph: normalizeGraphFromUnknown(root.graph) ?? graphFromTaskConfigPayload(root),
+    };
   } catch (error) {
     console.error("Failed to extract workflow:", error);
     return null;
   }
 };
 
-export const WorkflowGraphViewer = ({
-  selection,
-  snapshot,
-}: RendererProps): JSX.Element => {
-  // Try to find workflow from snapshot first (for workflow objects)
-  let workflow = snapshot.workflows.find(item => item.id === selection.objectId) ?? null;
-  
-  // For workspace files (run.json, ckpt.json), we need to extract workflow from the file
-  const [fileWorkflow, setFileWorkflow] = useState<any | null>(null);
+const parallelGraph: DisplayWorkflowGraph = {
+  nodes: [
+    {
+      nodeId: "start",
+      label: "Input Data",
+      nodeType: "input",
+      status: "succeeded",
+      position: { x: 250, y: 0 },
+      description: "Raw sequence",
+    },
+    {
+      nodeId: "preprocess",
+      label: "MSA Search",
+      nodeType: "task",
+      status: "succeeded",
+      position: { x: 250, y: 100 },
+      description: "Multiple Sequence Alignment",
+    },
+    {
+      nodeId: "model_1",
+      label: "Model 1",
+      nodeType: "task",
+      status: "succeeded",
+      position: { x: 50, y: 250 },
+      description: "Prediction Model 1",
+    },
+    {
+      nodeId: "model_2",
+      label: "Model 2",
+      nodeType: "task",
+      status: "failed",
+      position: { x: 250, y: 250 },
+      description: "Prediction Model 2 (Failed)",
+    },
+    {
+      nodeId: "model_3",
+      label: "Model 3",
+      nodeType: "task",
+      status: "skipped",
+      position: { x: 450, y: 250 },
+      description: "Prediction Model 3 (Skipped)",
+    },
+    {
+      nodeId: "consensus",
+      label: "Consensus",
+      nodeType: "task",
+      status: "running",
+      position: { x: 250, y: 400 },
+      description: "Ensemble voting",
+    },
+    {
+      nodeId: "output",
+      label: "PDB Structure",
+      nodeType: "output",
+      status: "pending",
+      position: { x: 250, y: 500 },
+      description: "Final structure",
+    },
+  ],
+  edges: [
+    { id: "e1", source: "start", target: "preprocess", label: "seq", status: "succeeded" },
+    { id: "e2", source: "preprocess", target: "model_1", label: "msa", status: "succeeded" },
+    { id: "e3", source: "preprocess", target: "model_2", label: "msa", status: "failed" },
+    { id: "e4", source: "preprocess", target: "model_3", label: "msa", status: "skipped" },
+    { id: "e5", source: "model_1", target: "consensus", label: "pdb", status: "running" },
+    { id: "e6", source: "model_2", target: "consensus", label: "pdb", status: "skipped" },
+    { id: "e7", source: "model_3", target: "consensus", label: "pdb", status: "skipped" },
+    { id: "e8", source: "consensus", target: "output", label: "best", status: "pending" },
+  ],
+};
+
+const loopGraph: DisplayWorkflowGraph = {
+  nodes: [
+    {
+      nodeId: "init",
+      label: "Init Params",
+      nodeType: "input",
+      status: "succeeded",
+      position: { x: 200, y: 0 },
+      description: "Initial configuration",
+    },
+    {
+      nodeId: "sim",
+      label: "Simulation",
+      nodeType: "task",
+      status: "succeeded",
+      position: { x: 200, y: 150 },
+      description: "Run dynamics",
+    },
+    {
+      nodeId: "eval",
+      label: "Evaluate Energy",
+      nodeType: "task",
+      status: "succeeded",
+      position: { x: 200, y: 300 },
+      description: "Check stability",
+    },
+    {
+      nodeId: "check",
+      label: "Converged?",
+      nodeType: "task",
+      status: "running",
+      position: { x: 200, y: 450 },
+      description: "Decision gate",
+    },
+    {
+      nodeId: "refine",
+      label: "Refine",
+      nodeType: "task",
+      status: "pending",
+      position: { x: 450, y: 225 },
+      description: "Adjust parameters",
+    },
+    {
+      nodeId: "final",
+      label: "Report",
+      nodeType: "output",
+      status: "pending",
+      position: { x: 200, y: 600 },
+      description: "Analysis report",
+    },
+  ],
+  edges: [
+    { id: "e1", source: "init", target: "sim", label: "start", status: "succeeded" },
+    { id: "e2", source: "sim", target: "eval", label: "traj", status: "succeeded" },
+    { id: "e3", source: "eval", target: "check", label: "score", status: "succeeded" },
+    { id: "e4", source: "check", target: "final", label: "yes", status: "pending" },
+    { id: "e5", source: "check", target: "refine", label: "no", status: "running", animated: true },
+    {
+      id: "e6",
+      source: "refine",
+      target: "sim",
+      label: "retry",
+      status: "pending",
+      animated: true,
+    },
+  ],
+};
+
+const asyncGraph: DisplayWorkflowGraph = {
+  nodes: [
+    {
+      nodeId: "trigger",
+      label: "Job Submission",
+      nodeType: "input",
+      status: "succeeded",
+      position: { x: 100, y: 100 },
+      description: "Submit to cluster",
+    },
+    {
+      nodeId: "remote",
+      label: "Remote Cluster",
+      nodeType: "task",
+      status: "running",
+      position: { x: 350, y: 100 },
+      description: "External computation",
+    },
+    {
+      nodeId: "monitor",
+      label: "Status Poller",
+      nodeType: "task",
+      status: "running",
+      position: { x: 350, y: 250 },
+      description: "Check status",
+    },
+    {
+      nodeId: "notify",
+      label: "Notification",
+      nodeType: "task",
+      status: "skipped",
+      position: { x: 100, y: 250 },
+      description: "Slack alert (Skipped)",
+    },
+    {
+      nodeId: "download",
+      label: "Fetch Results",
+      nodeType: "task",
+      status: "pending",
+      position: { x: 600, y: 100 },
+      description: "Download artifacts",
+    },
+  ],
+  edges: [
+    { id: "e1", source: "trigger", target: "remote", label: "submit", status: "succeeded" },
+    { id: "e2", source: "trigger", target: "notify", label: "started", status: "skipped" },
+    {
+      id: "e3",
+      source: "remote",
+      target: "monitor",
+      label: "heartbeat",
+      status: "running",
+      animated: true,
+    },
+    { id: "e4", source: "remote", target: "download", label: "done", status: "pending" },
+  ],
+};
+
+const getDemoGraph = (workflowId: string): DisplayWorkflowGraph => {
+  if (workflowId.includes("exp-002")) {
+    return loopGraph;
+  }
+  if (workflowId.includes("exp-101")) {
+    return asyncGraph;
+  }
+  return parallelGraph;
+};
+
+export const WorkflowGraphViewer = ({ selection, snapshot }: RendererProps): JSX.Element => {
+  const snapshotWorkflow =
+    snapshot.workflows.find((item) => item.id === selection.objectId) ?? null;
+  const [fileWorkflow, setFileWorkflow] = useState<FileWorkflowData | null>(null);
   const [isLoadingFile, setIsLoadingFile] = useState(false);
-  
+
   useEffect(() => {
-    if (selection.objectType === "workspace-file" && !workflow) {
-      setIsLoadingFile(true);
-      extractWorkflowFromFile(selection.objectId).then(extracted => {
-        setFileWorkflow(extracted);
-        setIsLoadingFile(false);
-      });
+    let cancelled = false;
+
+    if (selection.objectType !== "workspace-file") {
+      setFileWorkflow(null);
+      setIsLoadingFile(false);
+      return;
     }
-  }, [selection.objectId, selection.objectType]);
-  
-  // Use file workflow if available
-  if (selection.objectType === "workspace-file" && fileWorkflow) {
-    workflow = fileWorkflow;
-  }
-  
-  const isLoading = isLoadingFile;
-
-  // 1. Parallel Pattern (e.g. AlphaFold - Split/Merge)
-  const parallelGraph = {
-    nodes: [
-      { nodeId: "start", label: "Input Data", nodeType: "input", status: "succeeded", position: { x: 250, y: 0 }, description: "Raw sequence" },
-      { nodeId: "preprocess", label: "MSA Search", nodeType: "task", status: "succeeded", position: { x: 250, y: 100 }, description: "Multiple Sequence Alignment" },
-      { nodeId: "model_1", label: "Model 1", nodeType: "task", status: "succeeded", position: { x: 50, y: 250 }, description: "Prediction Model 1" },
-      { nodeId: "model_2", label: "Model 2", nodeType: "task", status: "failed", position: { x: 250, y: 250 }, description: "Prediction Model 2 (Failed)" },
-      { nodeId: "model_3", label: "Model 3", nodeType: "task", status: "skipped", position: { x: 450, y: 250 }, description: "Prediction Model 3 (Skipped)" },
-      { nodeId: "consensus", label: "Consensus", nodeType: "task", status: "running", position: { x: 250, y: 400 }, description: "Ensemble voting" },
-      { nodeId: "output", label: "PDB Structure", nodeType: "output", status: "pending", position: { x: 250, y: 500 }, description: "Final structure" },
-    ],
-    edges: [
-      { id: "e1", source: "start", target: "preprocess", label: "seq", status: "succeeded" },
-      { id: "e2", source: "preprocess", target: "model_1", label: "msa", status: "succeeded" },
-      { id: "e3", source: "preprocess", target: "model_2", label: "msa", status: "failed" },
-      { id: "e4", source: "preprocess", target: "model_3", label: "msa", status: "skipped" },
-      { id: "e5", source: "model_1", target: "consensus", label: "pdb", status: "running" },
-      { id: "e6", source: "model_2", target: "consensus", label: "pdb", status: "skipped" },
-      { id: "e7", source: "model_3", target: "consensus", label: "pdb", status: "skipped" },
-      { id: "e8", source: "consensus", target: "output", label: "best", status: "pending" },
-    ]
-  };
 
-  // 2. Loop Pattern (e.g. Structure Sweep - Optimization)
-  const loopGraph = {
-    nodes: [
-      { nodeId: "init", label: "Init Params", nodeType: "input", status: "succeeded", position: { x: 200, y: 0 }, description: "Initial configuration" },
-      { nodeId: "sim", label: "Simulation", nodeType: "task", status: "succeeded", position: { x: 200, y: 150 }, description: "Run dynamics" },
-      { nodeId: "eval", label: "Evaluate Energy", nodeType: "task", status: "succeeded", position: { x: 200, y: 300 }, description: "Check stability" },
-      { nodeId: "check", label: "Converged?", nodeType: "task", status: "running", position: { x: 200, y: 450 }, description: "Decision gate" },
-      { nodeId: "refine", label: "Refine", nodeType: "task", status: "pending", position: { x: 450, y: 225 }, description: "Adjust parameters" },
-      { nodeId: "final", label: "Report", nodeType: "output", status: "pending", position: { x: 200, y: 600 }, description: "Analysis report" },
-    ],
-    edges: [
-      { id: "e1", source: "init", target: "sim", label: "start", status: "succeeded" },
-      { id: "e2", source: "sim", target: "eval", label: "traj", status: "succeeded" },
-      { id: "e3", source: "eval", target: "check", label: "score", status: "succeeded" },
-      { id: "e4", source: "check", target: "final", label: "yes", status: "pending" },
-      { id: "e5", source: "check", target: "refine", label: "no", animated: true, status: "running" },
-      { id: "e6", source: "refine", target: "sim", label: "retry", animated: true, status: "pending" },
-    ]
-  };
+    setIsLoadingFile(true);
+    extractWorkflowFromFile(selection.objectId)
+      .then((extracted) => {
+        if (!cancelled) {
+          setFileWorkflow(extracted);
+        }
+      })
+      .finally(() => {
+        if (!cancelled) {
+          setIsLoadingFile(false);
+        }
+      });
 
-  // 3. Async Pattern (e.g. Catalyst - Remote Job)
-  const asyncGraph = {
-    nodes: [
-      { nodeId: "trigger", label: "Job Submission", nodeType: "input", status: "succeeded", position: { x: 100, y: 100 }, description: "Submit to cluster" },
-      { nodeId: "remote", label: "Remote Cluster", nodeType: "task", status: "running", position: { x: 350, y: 100 }, description: "External computation" },
-      { nodeId: "monitor", label: "Status Poller", nodeType: "task", status: "running", position: { x: 350, y: 250 }, description: "Check status" },
-      { nodeId: "notify", label: "Notification", nodeType: "task", status: "skipped", position: { x: 100, y: 250 }, description: "Slack alert (Skipped)" },
-      { nodeId: "download", label: "Fetch Results", nodeType: "task", status: "pending", position: { x: 600, y: 100 }, description: "Download artifacts" },
-    ],
-    edges: [
-      { id: "e1", source: "trigger", target: "remote", label: "submit", status: "succeeded" },
-      { id: "e2", source: "trigger", target: "notify", label: "started", status: "skipped" },
-      { id: "e3", source: "remote", target: "monitor", label: "heartbeat", animated: true, status: "running" },
-      { id: "e4", source: "remote", target: "download", label: "done", status: "pending" },
-    ]
-  };
+    return () => {
+      cancelled = true;
+    };
+  }, [selection.objectId, selection.objectType]);
 
-  const nodes = useMemo<Array<Node<WorkflowNodeData>>>(() => {
-    // Select mock graph based on workflow ID pattern
-    let graph = workflow?.graph;
-    
-    if (!graph && workflow) {
-      if (workflow.id.includes("exp-002")) {
-        graph = loopGraph;
-      } else if (workflow.id.includes("exp-101")) {
-        graph = asyncGraph;
-      } else {
-        graph = parallelGraph; // Default to parallel (exp-001)
-      }
+  const workflowId = snapshotWorkflow?.id ?? fileWorkflow?.id ?? selection.objectId;
+  const workflowName = snapshotWorkflow?.name ?? fileWorkflow?.name;
+
+  const graph = useMemo<DisplayWorkflowGraph | null>(() => {
+    if (snapshotWorkflow?.graph) {
+      return normalizeGraph(snapshotWorkflow.graph);
     }
+    if (fileWorkflow?.graph) {
+      return fileWorkflow.graph;
+    }
+    if (snapshotWorkflow || fileWorkflow) {
+      return getDemoGraph(workflowId);
+    }
+    return null;
+  }, [fileWorkflow, snapshotWorkflow, workflowId]);
 
-    if (!graph && !workflow) {
+  const nodes = useMemo<WorkflowFlowNode[]>(() => {
+    if (!graph) {
       return [];
     }
-
-    // @ts-ignore - graph structure mismatch workaround for demo
-    const nodeList = graph.nodes || graph; 
-    
-    if (!Array.isArray(nodeList)) return [];
-
-    return nodeList.map((node: any) => ({
-      id: node.nodeId || "unknown",
+    return graph.nodes.map((node) => ({
+      id: node.nodeId,
       type: "workflowNode",
-      position: node.position || { x: 0, y: 0 },
+      position: node.position,
       data: {
-        label: node.label || "Node",
-        nodeType: node.nodeType || "task",
-        status: node.status || "pending",
-        description: node.description || "",
+        label: node.label,
+        nodeType: node.nodeType,
+        status: node.status,
+        description: node.description,
       },
     }));
-  }, [workflow]);
+  }, [graph]);
 
   const edges = useMemo<Edge[]>(() => {
-    let graph = workflow?.graph;
-
-    if (!graph && workflow) {
-      if (workflow.id.includes("exp-002")) {
-        graph = loopGraph;
-      } else if (workflow.id.includes("exp-101")) {
-        graph = asyncGraph;
-      } else {
-        graph = parallelGraph;
-      }
+    if (!graph) {
+      return [];
     }
-
-    if (!graph) return [];
-
-    // @ts-ignore
-    const edgeList = graph.edges || [];
-
-    return edgeList.map((edge: any) => ({
-      id: edge.id || `e-${Math.random()}`,
+    return graph.edges.map((edge) => ({
+      id: edge.id,
       source: edge.source,
       target: edge.target,
       type: "smoothstep",
       animated: edge.animated || edge.status === "running",
       style: {
-        stroke: getEdgeColor(edge.status || "pending"),
+        stroke: getEdgeColor(edge.status),
         strokeWidth: 2,
       },
-      label: edge.label, // Pass label to edge
+      label: edge.label,
       markerEnd: {
         type: MarkerType.ArrowClosed,
-        color: getEdgeColor(edge.status || "pending"),
+        color: getEdgeColor(edge.status),
       },
     }));
-  }, [workflow]);
+  }, [graph]);
+
+  const nodeTypes = useMemo<NodeTypes>(() => ({ workflowNode: WorkflowNode }), []);
 
-  if (isLoading) {
+  if (isLoadingFile) {
     return (
       <Card>
         <CardHeader>
@@ -252,16 +599,14 @@ export const WorkflowGraphViewer = ({
     );
   }
 
-  if (!workflow) {
+  if (!snapshotWorkflow && !fileWorkflow) {
     return (
       <Card>
         <CardHeader>
           <CardTitle>Workflow Graph</CardTitle>
         </CardHeader>
         <CardContent>
-          <p className="text-sm text-muted-foreground">
-            No workflow data found in this file.
-          </p>
+          <p className="text-sm text-muted-foreground">No workflow data found in this file.</p>
         </CardContent>
       </Card>
     );
@@ -272,9 +617,7 @@ export const WorkflowGraphViewer = ({
       <CardHeader className="pb-3">
         <div className="flex items-center justify-between">
           <CardTitle className="text-lg">Workflow Graph</CardTitle>
-          {workflow.name && (
-            <Badge variant="outline">{workflow.name}</Badge>
-          )}
+          {workflowName && <Badge variant="outline">{workflowName}</Badge>}
         </div>
       </CardHeader>
       <CardContent className="flex-1 p-0">
@@ -282,7 +625,7 @@ export const WorkflowGraphViewer = ({
           <ReactFlow
             nodes={nodes}
             edges={edges}
-            nodeTypes={{ workflowNode: WorkflowNode }}
+            nodeTypes={nodeTypes}
             fitView
             attributionPosition="bottom-right"
           >
diff --git a/ui/src/app/renderers/WorkflowInspector.tsx b/ui/src/app/renderers/WorkflowInspector.tsx
index 9c30e487..939b9890 100644
--- a/ui/src/app/renderers/WorkflowInspector.tsx
+++ b/ui/src/app/renderers/WorkflowInspector.tsx
@@ -1,10 +1,10 @@
 import { useMemo } from "react";
+import { buildMetadataFields, type MetadataField } from "@/app/renderers/metadata";
+import type { RendererProps, WorkflowNodeMetadata } from "@/app/types";
 import { Badge } from "@/components/ui/badge";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Separator } from "@/components/ui/separator";
 import { Skeleton } from "@/components/ui/skeleton";
-import { buildMetadataFields, type MetadataField } from "@/app/renderers/metadata";
-import type { RendererProps, WorkflowNodeMetadata } from "@/app/types";
 
 const buildNodeFields = (node: WorkflowNodeMetadata | null): MetadataField[] => {
   if (!node) {
@@ -26,7 +26,7 @@ export const WorkflowInspector = ({
   inspectorTarget,
 }: RendererProps): JSX.Element => {
   const isLoading = false;
-  const workflow = snapshot.workflows.find(item => item.id === selection.objectId) ?? null;
+  const workflow = snapshot.workflows.find((item) => item.id === selection.objectId) ?? null;
 
   const workflowFields = useMemo<MetadataField[]>(() => {
     return buildMetadataFields(selection, snapshot);
@@ -37,7 +37,7 @@ export const WorkflowInspector = ({
       return [];
     }
     const node =
-      workflow.graph.nodes.find(item => item.nodeId === inspectorTarget.nodeId) ?? null;
+      workflow.graph.nodes.find((item) => item.nodeId === inspectorTarget.nodeId) ?? null;
     return buildNodeFields(node);
   }, [inspectorTarget, workflow]);
 
@@ -68,7 +68,7 @@ export const WorkflowInspector = ({
         {!isLoading && (
           <div className="space-y-4">
             <div className="space-y-2">
-              {workflowFields.map(field => (
+              {workflowFields.map((field) => (
                 <div key={field.label} className="space-y-1">
                   <p className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">
                     {field.label}
@@ -79,7 +79,7 @@ export const WorkflowInspector = ({
             </div>
             {showingNode && nodeFields.length > 0 && (
               <div className="space-y-2 border-t border-border/60 pt-4">
-                {nodeFields.map(field => (
+                {nodeFields.map((field) => (
                   <div key={field.label} className="space-y-1">
                     <p className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">
                       {field.label}
diff --git a/ui/src/app/renderers/WorkflowSourceViewer.tsx b/ui/src/app/renderers/WorkflowSourceViewer.tsx
index 5e83bc43..fc6f0993 100644
--- a/ui/src/app/renderers/WorkflowSourceViewer.tsx
+++ b/ui/src/app/renderers/WorkflowSourceViewer.tsx
@@ -1,13 +1,10 @@
-import { useEffect, useState } from "react";
 import Editor from "@monaco-editor/react";
-import { Card, CardContent } from "@/components/ui/card";
-import type { RendererProps } from "@/app/types";
+import { useEffect, useState } from "react";
 import { workspaceApi } from "@/app/state/api";
+import type { RendererProps } from "@/app/types";
+import { Card, CardContent } from "@/components/ui/card";
 
-export const WorkflowSourceViewer = ({
-  selection,
-  snapshot,
-}: RendererProps): JSX.Element => {
+export const WorkflowSourceViewer = ({ selection, snapshot }: RendererProps): JSX.Element => {
   const [content, setContent] = useState<string>("");
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
@@ -19,28 +16,26 @@ export const WorkflowSourceViewer = ({
   // We need to know where the workflow file is.
   // In `mapExperiments`: workflowFile: experiment.workflow.
   // So we can find the experiment by ID (experimentId is in workflow summary)
-  
-  const workflowPath = workflow?.summary || "workflow.yaml"; 
 
   useEffect(() => {
     if (!workflow) return;
 
     // Use summary as path for now, as consistent with api.ts mapping
-    const path = workflow.summary; 
-    
+    const path = workflow.summary;
+
     // If it looks like a path (contains .yaml, .json, or /), try deciding if absolute or relative?
     // Based on api.ts mapWorkflows, it's just `workflowPath` string.
-    
+
     setIsLoading(true);
-    // If it's a relative path, we might need to know the project path. 
+    // If it's a relative path, we might need to know the project path.
     // Usually these paths are relative to workspace root or project?
     // Let's assume relative to workspace root for now or try to fetch.
     // NOTE: experiment.workflow is usually just filename if in project root, or path.
     // api.ts calls `getWorkspaceFileText(path)`.
-    
+
     // Actually, `workflow.summary` might be just a description.
     // Let's check `workflow.experimentId`.
-    const experiment = snapshot.experiments.find(e => e.id === workflow?.experimentId);
+    const experiment = snapshot.experiments.find((e) => e.id === workflow?.experimentId);
     // experiment.workflowFile seems to be the path.
     const actualPath = experiment?.workflowFile || path;
 
@@ -60,7 +55,6 @@ export const WorkflowSourceViewer = ({
       });
   }, [workflow, snapshot.experiments]);
 
-
   if (isLoading) {
     return (
       <Card className="h-full border-0 shadow-none">
@@ -74,6 +68,9 @@ export const WorkflowSourceViewer = ({
   return (
     <Card className="h-full border-0 shadow-none">
       <CardContent className="h-full p-0">
+        {error && (
+          <div className="border-b border-border px-4 py-2 text-sm text-destructive">{error}</div>
+        )}
         <Editor
           height="100%"
           language="yaml"
diff --git a/ui/src/app/renderers/WorkflowViewer.tsx b/ui/src/app/renderers/WorkflowViewer.tsx
index 4a97e3f8..93222ce9 100644
--- a/ui/src/app/renderers/WorkflowViewer.tsx
+++ b/ui/src/app/renderers/WorkflowViewer.tsx
@@ -1,73 +1,69 @@
-import { Badge } from "@/components/ui/badge";
 import { Workflow } from "lucide-react";
-import type { RendererProps } from "@/app/types";
+import { EntityHeader, KeyValueGrid } from "@/app/components/entity";
 import { TabbedViewer } from "@/app/renderers/TabbedViewer";
 import { WorkflowGraphViewer } from "@/app/renderers/WorkflowGraphViewer";
 import { WorkflowSourceViewer } from "@/app/renderers/WorkflowSourceViewer";
+import { useNavigationState } from "@/app/state/useNavigationState";
+import type { RendererProps } from "@/app/types";
 
-const WorkflowOverview = ({
-  selection,
-  snapshot,
-}: RendererProps): JSX.Element => {
+const WorkflowOverview = ({ selection, snapshot }: RendererProps): JSX.Element => {
   const workflowId = selection.objectId;
   const workflow = snapshot.workflows.find((w) => w.id === workflowId);
+  const { breadcrumbs, canNavigateUp, navigateUp } = useNavigationState(snapshot);
 
   if (!workflow) {
     return <div className="p-8 text-muted-foreground">Workflow not found.</div>;
   }
 
   return (
-    <div className="flex h-full flex-col bg-background overflow-y-auto">
-      <div className="flex flex-col gap-6 px-8 py-8 border-b bg-background">
-        <div className="flex items-start justify-between">
-          <div className="space-y-1">
-            <div className="flex items-center gap-3">
-              <div className="p-2 bg-blue-500/10 rounded-lg">
-                <Workflow className="h-6 w-6 text-blue-600" />
-              </div>
-              <h1 className="text-3xl font-bold tracking-tight text-foreground">{workflow.name}</h1>
-            </div>
-            <div className="flex items-center gap-2 pl-[3.25rem]">
-              <Badge variant="outline" className="font-mono text-xs text-muted-foreground">
-                {workflowId}
-              </Badge>
+    <div className="flex h-full flex-col overflow-y-auto bg-background">
+      <EntityHeader
+        breadcrumbs={breadcrumbs}
+        canNavigateUp={canNavigateUp}
+        onNavigateUp={navigateUp}
+        icon={Workflow}
+        title={workflow.name}
+        status={workflow.status}
+        subtitle={workflow.summary || undefined}
+      />
+
+      <div className="flex-1 overflow-auto p-6 md:p-8">
+        <div className="max-w-3xl space-y-6">
+          <div>
+            <h3 className="text-sm font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+              Summary
+            </h3>
+            <p className="mt-3 max-w-2xl text-sm leading-6 text-foreground">
+              {workflow.summary || "No summary provided."}
+            </p>
+          </div>
+
+          <div>
+            <h3 className="text-sm font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+              Metadata
+            </h3>
+            <div className="mt-4">
+              <KeyValueGrid
+                items={[
+                  {
+                    label: "Workflow ID",
+                    value: <span className="font-mono text-xs">{workflow.id}</span>,
+                  },
+                  {
+                    label: "Project ID",
+                    value: <span className="font-mono text-xs">{workflow.projectId}</span>,
+                  },
+                  {
+                    label: "Experiment ID",
+                    value: <span className="font-mono text-xs">{workflow.experimentId}</span>,
+                  },
+                  { label: "Last Updated", value: new Date(workflow.updatedAt).toLocaleString() },
+                ]}
+              />
             </div>
           </div>
         </div>
       </div>
-      
-      <div className="flex-1 p-8 space-y-6">
-        <div className="space-y-2">
-             <h3 className="text-lg font-semibold">Summary</h3>
-             <div className="rounded-md border p-4 bg-muted/20">
-                <p className="text-sm">
-                    {workflow.summary || "No summary available."}
-                </p>
-             </div>
-        </div>
-        
-        <div className="space-y-2">
-            <h3 className="text-lg font-semibold">Metadata</h3>
-             <div className="grid grid-cols-2 gap-4">
-                <div className="p-4 rounded-md border bg-card">
-                    <p className="text-xs text-muted-foreground uppercase">Project ID</p>
-                    <p className="font-mono text-sm">{workflow.projectId}</p>
-                </div>
-                <div className="p-4 rounded-md border bg-card">
-                    <p className="text-xs text-muted-foreground uppercase">Experiment ID</p>
-                    <p className="font-mono text-sm">{workflow.experimentId}</p>
-                </div>
-                <div className="p-4 rounded-md border bg-card">
-                    <p className="text-xs text-muted-foreground uppercase">Last Updated</p>
-                    <p className="text-sm">{new Date(workflow.updatedAt).toLocaleString()}</p>
-                </div>
-                <div className="p-4 rounded-md border bg-card">
-                    <p className="text-xs text-muted-foreground uppercase">Status</p>
-                    <p className="text-sm capitalize">{workflow.status}</p>
-                </div>
-             </div>
-        </div>
-      </div>
     </div>
   );
 };
diff --git a/ui/src/app/renderers/metadata.ts b/ui/src/app/renderers/metadata.ts
index 3b202906..edaa6d79 100644
--- a/ui/src/app/renderers/metadata.ts
+++ b/ui/src/app/renderers/metadata.ts
@@ -1,12 +1,13 @@
 import type {
+  AgentSessionSummary,
   AssetSummary,
   ExperimentSummary,
   ProjectSummary,
   RunSummary,
-  SemanticObjectType,
   Selection,
-  WorkspaceSnapshot,
+  SemanticObjectType,
   WorkflowSummary,
+  WorkspaceSnapshot,
 } from "@/app/types";
 
 export interface MetadataField {
@@ -14,39 +15,28 @@ export interface MetadataField {
   value: string;
 }
 
-const findProject = (
-  snapshot: WorkspaceSnapshot,
-  id: string,
-): ProjectSummary | null => {
-  return snapshot.projects.find(project => project.id === id) ?? null;
+const findProject = (snapshot: WorkspaceSnapshot, id: string): ProjectSummary | null => {
+  return snapshot.projects.find((project) => project.id === id) ?? null;
 };
 
-const findExperiment = (
-  snapshot: WorkspaceSnapshot,
-  id: string,
-): ExperimentSummary | null => {
-  return snapshot.experiments.find(experiment => experiment.id === id) ?? null;
+const findExperiment = (snapshot: WorkspaceSnapshot, id: string): ExperimentSummary | null => {
+  return snapshot.experiments.find((experiment) => experiment.id === id) ?? null;
 };
 
-const findRun = (
-  snapshot: WorkspaceSnapshot,
-  id: string,
-): RunSummary | null => {
-  return snapshot.runs.find(run => run.id === id) ?? null;
+const findRun = (snapshot: WorkspaceSnapshot, id: string): RunSummary | null => {
+  return snapshot.runs.find((run) => run.id === id) ?? null;
 };
 
-const findAsset = (
-  snapshot: WorkspaceSnapshot,
-  id: string,
-): AssetSummary | null => {
-  return snapshot.assets.find(asset => asset.id === id) ?? null;
+const findAsset = (snapshot: WorkspaceSnapshot, id: string): AssetSummary | null => {
+  return snapshot.assets.find((asset) => asset.id === id) ?? null;
 };
 
-const findWorkflow = (
-  snapshot: WorkspaceSnapshot,
-  id: string,
-): WorkflowSummary | null => {
-  return snapshot.workflows.find(workflow => workflow.id === id) ?? null;
+const findAgentSession = (snapshot: WorkspaceSnapshot, id: string): AgentSessionSummary | null => {
+  return snapshot.agentSessions.find((s) => s.id === id) ?? null;
+};
+
+const findWorkflow = (snapshot: WorkspaceSnapshot, id: string): WorkflowSummary | null => {
+  return snapshot.workflows.find((workflow) => workflow.id === id) ?? null;
 };
 
 const emptyFields = (objectType: SemanticObjectType, objectId: string): MetadataField[] => {
@@ -61,10 +51,7 @@ export const buildMetadataFields = (
   selection: Selection,
   snapshot: WorkspaceSnapshot,
 ): MetadataField[] => {
-  const lookupByType: Record<
-    SemanticObjectType,
-    () => MetadataField[]
-  > = {
+  const lookupByType: Record<SemanticObjectType, () => MetadataField[]> = {
     project: () => {
       const project = findProject(snapshot, selection.objectId);
       if (!project) {
@@ -95,7 +82,7 @@ export const buildMetadataFields = (
       if (!run) {
         return emptyFields("run", selection.objectId);
       }
-      return [
+      const fields: MetadataField[] = [
         { label: "Run", value: run.name },
         { label: "Project", value: run.projectId },
         { label: "Experiment", value: run.experimentId },
@@ -103,6 +90,16 @@ export const buildMetadataFields = (
         { label: "Summary", value: run.summary },
         { label: "Updated", value: run.updatedAt },
       ];
+      if (run.executorInfo.backend) {
+        fields.push({ label: "Backend", value: run.executorInfo.backend });
+      }
+      if (run.executorInfo.scheduler) {
+        fields.push({ label: "Scheduler", value: run.executorInfo.scheduler });
+      }
+      if (run.executorInfo.job_id) {
+        fields.push({ label: "Job ID", value: run.executorInfo.job_id });
+      }
+      return fields;
     },
     asset: () => {
       const asset = findAsset(snapshot, selection.objectId);
@@ -131,6 +128,19 @@ export const buildMetadataFields = (
         { label: "Updated", value: workflow.updatedAt },
       ];
     },
+    agent: () => {
+      const session = findAgentSession(snapshot, selection.objectId);
+      if (!session) {
+        return emptyFields("agent", selection.objectId);
+      }
+      return [
+        { label: "Session", value: session.id },
+        { label: "Status", value: session.status },
+        { label: "Goal", value: session.goalDescription },
+        { label: "Events", value: String(session.eventCount) },
+        { label: "Created", value: session.createdAt },
+      ];
+    },
     "workspace-file": () => {
       if (selection.objectType !== "workspace-file") {
         return emptyFields("workspace-file", selection.objectId);
diff --git a/ui/src/app/renderers/registerRenderers.ts b/ui/src/app/renderers/registerRenderers.ts
index 8af87973..f90f3455 100644
--- a/ui/src/app/renderers/registerRenderers.ts
+++ b/ui/src/app/renderers/registerRenderers.ts
@@ -1,13 +1,14 @@
 import { registerRenderer } from "@/app/registry";
-import { MetadataViewer } from "@/app/renderers/MetadataViewer";
-import { MetadataInspector } from "@/app/renderers/MetadataInspector";
-import { TextEditor } from "@/app/renderers/TextEditor";
-import { WorkflowInspector } from "@/app/renderers/WorkflowInspector";
+import { AgentViewer } from "@/app/renderers/AgentViewer";
+import { AssetViewer } from "@/app/renderers/AssetViewer";
+import { ExperimentViewer } from "@/app/renderers/ExperimentViewer";
 import { ImageViewer } from "@/app/renderers/ImageViewer";
-import { WorkflowFileViewer } from "@/app/renderers/WorkflowFileViewer";
+import { MetadataInspector } from "@/app/renderers/MetadataInspector";
 import { ProjectViewer } from "@/app/renderers/ProjectViewer";
-import { ExperimentViewer } from "@/app/renderers/ExperimentViewer";
 import { RunViewer } from "@/app/renderers/RunViewer";
+import { TextEditor } from "@/app/renderers/TextEditor";
+import { WorkflowFileViewer } from "@/app/renderers/WorkflowFileViewer";
+import { WorkflowInspector } from "@/app/renderers/WorkflowInspector";
 import { WorkflowViewer } from "@/app/renderers/WorkflowViewer";
 
 export const registerDefaultRenderers = (): void => {
@@ -56,7 +57,7 @@ export const registerDefaultRenderers = (): void => {
     },
     title: "Asset Overview",
     panelSlot: "center",
-    Component: MetadataViewer,
+    Component: AssetViewer,
   });
 
   registerRenderer({
@@ -71,9 +72,17 @@ export const registerDefaultRenderers = (): void => {
     Component: WorkflowViewer,
   });
 
-  const workspaceFileKinds = ["yaml", "json", "python", "markdown", "text", "unknown", "image"] as const;
+  const workspaceFileKinds = [
+    "yaml",
+    "json",
+    "python",
+    "markdown",
+    "text",
+    "unknown",
+    "image",
+  ] as const;
   const editorFileKinds = ["yaml", "json", "python", "markdown", "text", "unknown"] as const;
-  editorFileKinds.forEach(fileKind => {
+  editorFileKinds.forEach((fileKind) => {
     registerRenderer({
       key: {
         objectType: "workspace-file",
@@ -171,7 +180,7 @@ export const registerDefaultRenderers = (): void => {
     Component: WorkflowInspector,
   });
 
-  workspaceFileKinds.forEach(fileKind => {
+  workspaceFileKinds.forEach((fileKind) => {
     registerRenderer({
       key: {
         objectType: "workspace-file",
@@ -184,4 +193,28 @@ export const registerDefaultRenderers = (): void => {
       Component: MetadataInspector,
     });
   });
+
+  registerRenderer({
+    key: {
+      objectType: "agent",
+      fileKind: "json",
+      contentType: "metadata",
+      panelKind: "viewer",
+    },
+    title: "Agent Session",
+    panelSlot: "center",
+    Component: AgentViewer,
+  });
+
+  registerRenderer({
+    key: {
+      objectType: "agent",
+      fileKind: "json",
+      contentType: "metadata",
+      panelKind: "inspector",
+    },
+    title: "Agent Inspector",
+    panelSlot: "right",
+    Component: MetadataInspector,
+  });
 };
diff --git a/ui/src/app/state/api.test.ts b/ui/src/app/state/api.test.ts
new file mode 100644
index 00000000..e6a376c3
--- /dev/null
+++ b/ui/src/app/state/api.test.ts
@@ -0,0 +1,303 @@
+/**
+ * Tests for app/state/api.ts — pure mapping functions.
+ *
+ * Per project convention:
+ * - describe('functionName') wraps each exported function
+ * - it('...') covers one behaviour per case
+ * - shared mock data lives in src/__fixtures__/api.ts
+ */
+
+import { describe, expect, it } from "@rstest/core";
+import {
+  fixtureAsset,
+  fixtureExperiment,
+  fixtureExperimentNoDescription,
+  fixtureProject,
+  fixtureProjectNoDescription,
+  fixtureRun,
+  fixtureRunCancelled,
+  fixtureRunFailed,
+  fixtureRunPending,
+} from "@/__fixtures__/api";
+import {
+  buildEmptySnapshot,
+  emptyConsoleEntries,
+  mapAgentSessions,
+  mapAssets,
+  mapExperiments,
+  mapProjects,
+  mapRuns,
+  mapWorkflows,
+  mapWorkspaceTree,
+} from "@/app/state/api";
+
+describe("buildEmptySnapshot", () => {
+  it("returns empty arrays for all collections", () => {
+    const snap = buildEmptySnapshot();
+    expect(snap.projects).toEqual([]);
+    expect(snap.experiments).toEqual([]);
+    expect(snap.runs).toEqual([]);
+    expect(snap.assets).toEqual([]);
+    expect(snap.workflows).toEqual([]);
+    expect(snap.agentSessions).toEqual([]);
+    expect(snap.consoleEntries).toEqual([]);
+  });
+
+  it("sets workspaceRoot to null", () => {
+    expect(buildEmptySnapshot().workspaceRoot).toBeNull();
+  });
+});
+
+describe("emptyConsoleEntries", () => {
+  it("returns an empty array", () => {
+    expect(emptyConsoleEntries()).toEqual([]);
+  });
+});
+
+describe("mapProjects", () => {
+  it("maps id and name from API response", () => {
+    const [result] = mapProjects([fixtureProject]);
+    expect(result.id).toBe("proj-alpha");
+    expect(result.name).toBe("Alpha Project");
+  });
+
+  it("uses description as summary when present", () => {
+    const [result] = mapProjects([fixtureProject]);
+    expect(result.summary).toBe("First project");
+  });
+
+  it("falls back to 'No description' when description is absent", () => {
+    const [result] = mapProjects([fixtureProjectNoDescription]);
+    expect(result.summary).toBe("No description");
+  });
+
+  it("sets status to 'active'", () => {
+    const [result] = mapProjects([fixtureProject]);
+    expect(result.status).toBe("active");
+  });
+
+  it("maps updatedAt from created timestamp", () => {
+    const [result] = mapProjects([fixtureProject]);
+    expect(result.updatedAt).toBe(fixtureProject.created);
+  });
+
+  it("maps an empty array to an empty array", () => {
+    expect(mapProjects([])).toEqual([]);
+  });
+
+  it("preserves order of multiple projects", () => {
+    const results = mapProjects([fixtureProject, fixtureProjectNoDescription]);
+    expect(results[0].id).toBe("proj-alpha");
+    expect(results[1].id).toBe("proj-beta");
+  });
+});
+
+describe("mapExperiments", () => {
+  it("maps id, name, and projectId", () => {
+    const [result] = mapExperiments("proj-alpha", [fixtureExperiment]);
+    expect(result.id).toBe("exp-001");
+    expect(result.name).toBe("Baseline");
+    expect(result.projectId).toBe("proj-alpha");
+  });
+
+  it("uses description as summary when present", () => {
+    const [result] = mapExperiments("proj-alpha", [fixtureExperiment]);
+    expect(result.summary).toBe("Baseline experiment");
+  });
+
+  it("falls back to workflow path when description is absent", () => {
+    const [result] = mapExperiments("proj-alpha", [fixtureExperimentNoDescription]);
+    expect(result.summary).toBe("variant.py");
+  });
+
+  it("sets workflowFile from workflow field", () => {
+    const [result] = mapExperiments("proj-alpha", [fixtureExperiment]);
+    expect(result.workflowFile).toBe("workflow.py");
+  });
+
+  it("maps an empty array to an empty array", () => {
+    expect(mapExperiments("proj-alpha", [])).toEqual([]);
+  });
+});
+
+describe("mapRuns", () => {
+  it("maps id and name from runId", () => {
+    const [result] = mapRuns("proj-alpha", "exp-001", [fixtureRun]);
+    expect(result.id).toBe("run-abc");
+    expect(result.name).toBe("run-abc");
+  });
+
+  it("maps projectId and experimentId", () => {
+    const [result] = mapRuns("proj-alpha", "exp-001", [fixtureRun]);
+    expect(result.projectId).toBe("proj-alpha");
+    expect(result.experimentId).toBe("exp-001");
+  });
+
+  it("maps status 'succeeded'", () => {
+    const [result] = mapRuns("p", "e", [fixtureRun]);
+    expect(result.status).toBe("succeeded");
+  });
+
+  it("maps status 'pending'", () => {
+    const [result] = mapRuns("p", "e", [fixtureRunPending]);
+    expect(result.status).toBe("pending");
+  });
+
+  it("maps status 'failed'", () => {
+    const [result] = mapRuns("p", "e", [fixtureRunFailed]);
+    expect(result.status).toBe("failed");
+  });
+
+  it("maps status 'cancelled'", () => {
+    const [result] = mapRuns("p", "e", [fixtureRunCancelled]);
+    expect(result.status).toBe("cancelled");
+  });
+
+  it("uses finished timestamp for updatedAt when available", () => {
+    const [result] = mapRuns("p", "e", [fixtureRun]);
+    expect(result.updatedAt).toBe("2026-03-01T12:00:00Z");
+  });
+
+  it("falls back to created when finished is absent", () => {
+    const [result] = mapRuns("p", "e", [fixtureRunPending]);
+    expect(result.updatedAt).toBe(fixtureRunPending.created);
+  });
+
+  it("maps an empty array to an empty array", () => {
+    expect(mapRuns("p", "e", [])).toEqual([]);
+  });
+});
+
+describe("mapAssets", () => {
+  it("maps id from asset.id", () => {
+    const [result] = mapAssets([fixtureAsset]);
+    expect(result.id).toBe("asset-001");
+  });
+
+  it("maps name from assetId", () => {
+    const [result] = mapAssets([fixtureAsset]);
+    expect(result.name).toBe("asset-001");
+  });
+
+  it("builds summary from type and format", () => {
+    const [result] = mapAssets([fixtureAsset]);
+    expect(result.summary).toBe("model • pickle");
+  });
+
+  it("maps sizeBytes", () => {
+    const [result] = mapAssets([fixtureAsset]);
+    expect(result.sizeBytes).toBe(1024);
+  });
+
+  it("forwards optional projectId", () => {
+    const [withProject] = mapAssets([fixtureAsset], "proj-alpha");
+    expect(withProject.projectId).toBe("proj-alpha");
+
+    const [withoutProject] = mapAssets([fixtureAsset]);
+    expect(withoutProject.projectId).toBeUndefined();
+  });
+});
+
+describe("mapWorkflows", () => {
+  it("constructs workflow id from experiment id", () => {
+    const rawExp = [fixtureExperiment];
+    const expSummaries = mapExperiments("proj-alpha", rawExp);
+    const [result] = mapWorkflows(expSummaries, rawExp);
+    expect(result.id).toBe("workflow:exp-001");
+  });
+
+  it("names workflow from experiment name", () => {
+    const rawExp = [fixtureExperiment];
+    const expSummaries = mapExperiments("proj-alpha", rawExp);
+    const [result] = mapWorkflows(expSummaries, rawExp);
+    expect(result.name).toBe("Baseline workflow");
+  });
+
+  it("sets summary to workflow path", () => {
+    const rawExp = [fixtureExperiment];
+    const expSummaries = mapExperiments("proj-alpha", rawExp);
+    const [result] = mapWorkflows(expSummaries, rawExp);
+    expect(result.summary).toBe("workflow.py");
+  });
+
+  it("maps an empty array to an empty array", () => {
+    expect(mapWorkflows([], [])).toEqual([]);
+  });
+});
+
+describe("mapWorkspaceTree", () => {
+  it("sets id to 'workspace-root'", () => {
+    const result = mapWorkspaceTree("/ws", {});
+    expect(result.id).toBe("workspace-root");
+  });
+
+  it("uses response.path when present", () => {
+    const result = mapWorkspaceTree("/fallback", { path: "/actual/path" });
+    expect(result.name).toBe("/actual/path");
+    expect(result.path).toBe("/actual/path");
+  });
+
+  it("falls back to rootPath when response.path is absent", () => {
+    const result = mapWorkspaceTree("/fallback", {});
+    expect(result.name).toBe("/fallback");
+  });
+
+  it("maps children recursively", () => {
+    const result = mapWorkspaceTree("/ws", {
+      children: [
+        { name: "src", path: "/ws/src", type: "directory" },
+        { name: "main.py", path: "/ws/main.py", type: "file" },
+      ],
+    });
+    expect(result.children).toHaveLength(2);
+    expect(result.children[0].kind).toBe("directory");
+    expect(result.children[1].kind).toBe("file");
+  });
+
+  it("produces empty children array when response has none", () => {
+    const result = mapWorkspaceTree("/ws", {});
+    expect(result.children).toEqual([]);
+  });
+});
+
+describe("mapAgentSessions", () => {
+  const rawSession = {
+    sessionId: "sess-abc",
+    status: "completed",
+    goalDescription: "Run baseline experiment",
+    createdAt: "2026-03-01T10:00:00Z",
+    events: [
+      { type: "PlanCreatedEvent", ts: "2026-03-01T10:00:01Z", payload: {} },
+      { type: "SessionCompletedEvent", ts: "2026-03-01T10:05:00Z", payload: {} },
+    ],
+  };
+
+  it("maps sessionId to id", () => {
+    const [result] = mapAgentSessions([rawSession]);
+    expect(result.id).toBe("sess-abc");
+  });
+
+  it("maps goalDescription", () => {
+    const [result] = mapAgentSessions([rawSession]);
+    expect(result.goalDescription).toBe("Run baseline experiment");
+  });
+
+  it("maps status", () => {
+    const [result] = mapAgentSessions([rawSession]);
+    expect(result.status).toBe("completed");
+  });
+
+  it("maps createdAt", () => {
+    const [result] = mapAgentSessions([rawSession]);
+    expect(result.createdAt).toBe("2026-03-01T10:00:00Z");
+  });
+
+  it("counts events", () => {
+    const [result] = mapAgentSessions([rawSession]);
+    expect(result.eventCount).toBe(2);
+  });
+
+  it("maps an empty array to an empty array", () => {
+    expect(mapAgentSessions([])).toEqual([]);
+  });
+});
diff --git a/ui/src/app/state/api.ts b/ui/src/app/state/api.ts
index 44938a0f..165d8b2a 100644
--- a/ui/src/app/state/api.ts
+++ b/ui/src/app/state/api.ts
@@ -1,27 +1,31 @@
+import { AssetsService } from "@/api/generated/services/AssetsService";
+import { ExecutionService } from "@/api/generated/services/ExecutionService";
+import { ExperimentsService } from "@/api/generated/services/ExperimentsService";
+import { ProjectsService } from "@/api/generated/services/ProjectsService";
+import { RunsService } from "@/api/generated/services/RunsService";
+import { WorkspaceService } from "@/api/generated/services/WorkspaceService";
 import type {
+  AgentSessionSummary,
+  ApiAgentSession,
   ApiAssetResponse,
+  ApiCacheClear,
+  ApiCacheStats,
   ApiExperimentResponse,
   ApiProjectResponse,
   ApiRunResponse,
   AssetSummary,
   ConsoleEntry,
+  ExperimentCreateRequest,
   ExperimentSummary,
+  ProjectCreateRequest,
   ProjectSummary,
+  RunCreateRequest,
   RunSummary,
   WorkflowSummary,
   WorkspaceSnapshot,
   WorkspaceTreeNode,
-  ProjectCreateRequest,
-  ExperimentCreateRequest,
-  RunCreateRequest,
 } from "@/app/types";
 
-import { ProjectsService } from "@/api/generated/services/ProjectsService";
-import { ExperimentsService } from "@/api/generated/services/ExperimentsService";
-import { RunsService } from "@/api/generated/services/RunsService";
-import { AssetsService } from "@/api/generated/services/AssetsService";
-import { WorkspaceService } from "@/api/generated/services/WorkspaceService";
-
 // Local types not yet in OpenAPI
 interface WorkspaceFileNode {
   id?: string;
@@ -58,17 +62,27 @@ export const workspaceApi = {
     return ExperimentsService.createExperimentApiProjectsProjectIdExperimentsPost(projectId, data);
   },
   deleteExperiment: async (projectId: string, experimentId: string): Promise<void> => {
-    await ExperimentsService.deleteExperimentApiProjectsProjectIdExperimentsExperimentIdDelete(projectId, experimentId);
+    await ExperimentsService.deleteExperimentApiProjectsProjectIdExperimentsExperimentIdDelete(
+      projectId,
+      experimentId,
+    );
   },
   getRuns: async (projectId: string, experimentId: string): Promise<ApiRunResponse[]> => {
-    return RunsService.listRunsApiProjectsProjectIdExperimentsExperimentIdRunsGet(projectId, experimentId);
+    return RunsService.listRunsApiProjectsProjectIdExperimentsExperimentIdRunsGet(
+      projectId,
+      experimentId,
+    );
   },
   createRun: async (
     projectId: string,
     experimentId: string,
     data: RunCreateRequest,
   ): Promise<ApiRunResponse> => {
-    return RunsService.createRunApiProjectsProjectIdExperimentsExperimentIdRunsPost(projectId, experimentId, data);
+    return RunsService.createRunApiProjectsProjectIdExperimentsExperimentIdRunsPost(
+      projectId,
+      experimentId,
+      data,
+    );
   },
   getAssets: async (): Promise<ApiAssetResponse[]> => {
     return AssetsService.listAssetsApiAssetsGet();
@@ -86,10 +100,16 @@ export const workspaceApi = {
     return response as unknown as WorkspaceFilesResponse;
   },
   openWorkspace: async (path: string, createIfMissing = false): Promise<void> => {
-    await WorkspaceService.openWorkspaceApiWorkspaceOpenPost({ path, create_if_missing: createIfMissing });
+    await WorkspaceService.openWorkspaceApiWorkspaceOpenPost({
+      path,
+      create_if_missing: createIfMissing,
+    });
   },
   createDirectory: async (path: string): Promise<void> => {
-    await WorkspaceService.createDirectoryApiWorkspaceDirectoriesPost({ folder_id: "workspace", path });
+    await WorkspaceService.createDirectoryApiWorkspaceDirectoriesPost({
+      folder_id: "workspace",
+      path,
+    });
   },
   writeFile: async (path: string, content = ""): Promise<void> => {
     await WorkspaceService.writeFileApiWorkspaceFilesPut({ folder_id: "workspace", path, content });
@@ -98,6 +118,12 @@ export const workspaceApi = {
     const response = await WorkspaceService.readWorkspaceFileApiWorkspaceFileGet(path);
     return response.content;
   },
+  getCacheStats: async (): Promise<ApiCacheStats> => {
+    return ExecutionService.getCacheStatsApiCacheStatsGet();
+  },
+  clearCache: async (): Promise<ApiCacheClear> => {
+    return ExecutionService.clearCacheApiCacheDelete();
+  },
   getWorkspaceFileBlob: async (path: string): Promise<Blob> => {
     // The generated client currently returns 'any' (JSON) for blob endpoint if not configured for binary.
     // For now we might need to fallback to manual fetch for Blob if strictly required,
@@ -120,13 +146,14 @@ export const buildEmptySnapshot = (): WorkspaceSnapshot => {
     runs: [],
     assets: [],
     workflows: [],
+    agentSessions: [],
     workspaceRoot: null,
     consoleEntries: [],
   };
 };
 
 export const mapProjects = (projects: ApiProjectResponse[]): ProjectSummary[] => {
-  return projects.map(project => ({
+  return projects.map((project) => ({
     id: project.id,
     name: project.name,
     status: "active",
@@ -139,7 +166,7 @@ export const mapExperiments = (
   projectId: string,
   experiments: ApiExperimentResponse[],
 ): ExperimentSummary[] => {
-  return experiments.map(experiment => ({
+  return experiments.map((experiment) => ({
     id: experiment.id,
     name: experiment.name,
     status: "active",
@@ -171,9 +198,12 @@ export const mapRuns = (
     return "pending";
   };
 
-  return runs.map(run => ({
+  return runs.map((run) => ({
+    executorInfo: Object.fromEntries(
+      Object.entries(run.executorInfo ?? {}).map(([key, value]) => [key, String(value)]),
+    ),
     id: run.id,
-    name: run.runId,
+    name: "runId" in run && typeof run.runId === "string" ? run.runId : run.id,
     status: mapStatus(run.status),
     summary: `Status: ${run.status}`,
     updatedAt: run.finished ?? run.created,
@@ -183,7 +213,7 @@ export const mapRuns = (
 };
 
 export const mapAssets = (assets: ApiAssetResponse[], projectId?: string): AssetSummary[] => {
-  return assets.map(asset => ({
+  return assets.map((asset) => ({
     id: asset.id,
     name: asset.assetId,
     status: "active",
@@ -198,8 +228,8 @@ export const mapWorkflows = (
   experiments: ExperimentSummary[],
   rawExperiments: ApiExperimentResponse[],
 ): WorkflowSummary[] => {
-  const experimentById = new Map(rawExperiments.map(experiment => [experiment.id, experiment]));
-  return experiments.map(experiment => {
+  const experimentById = new Map(rawExperiments.map((experiment) => [experiment.id, experiment]));
+  return experiments.map((experiment) => {
     const raw = experimentById.get(experiment.id);
     const workflowPath = raw ? raw.workflow : "workflow";
     return {
@@ -216,14 +246,12 @@ export const mapWorkflows = (
 
 export const emptyConsoleEntries = (): ConsoleEntry[] => [];
 
-
-
 const mapWorkspaceNode = (node: WorkspaceFileNode): WorkspaceTreeNode => {
   const isFile = node.type === "file";
   const updatedAt =
     typeof node.modified === "number"
       ? new Date(node.modified * 1000).toISOString()
-      : node.modified ?? "";
+      : (node.modified ?? "");
   return {
     id: node.id ?? node.path,
     name: node.name,
@@ -249,3 +277,58 @@ export const mapWorkspaceTree = (
     updatedAt: "",
   };
 };
+
+export const mapAgentSessions = (sessions: ApiAgentSession[]): AgentSessionSummary[] => {
+  return sessions.map((s) => ({
+    id: s.sessionId,
+    goalDescription: s.goalDescription,
+    status: s.status as AgentSessionSummary["status"],
+    createdAt: s.createdAt,
+    eventCount: s.events.length,
+  }));
+};
+
+export const agentApi = {
+  listSessions: async (): Promise<ApiAgentSession[]> => {
+    const response = await fetch("/api/agent/sessions");
+    if (!response.ok) throw new Error(`Failed to fetch sessions: ${response.statusText}`);
+    const data = await response.json();
+    return data.sessions ?? [];
+  },
+
+  createSession: async (
+    description: string,
+    successCriteria: string[] = [],
+  ): Promise<ApiAgentSession> => {
+    const response = await fetch("/api/agent/sessions", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ description, success_criteria: successCriteria }),
+    });
+    if (!response.ok) throw new Error(`Failed to create session: ${response.statusText}`);
+    return response.json();
+  },
+
+  getSession: async (sessionId: string): Promise<ApiAgentSession> => {
+    const response = await fetch(`/api/agent/sessions/${sessionId}`);
+    if (!response.ok) throw new Error(`Failed to fetch session: ${response.statusText}`);
+    return response.json();
+  },
+
+  streamEvents: (sessionId: string): EventSource => {
+    return new EventSource(`/api/agent/sessions/${sessionId}/events`);
+  },
+
+  respondApproval: async (
+    sessionId: string,
+    requestId: string,
+    approved: boolean,
+  ): Promise<void> => {
+    const response = await fetch(`/api/agent/sessions/${sessionId}/approve`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ request_id: requestId, approved }),
+    });
+    if (!response.ok) throw new Error(`Failed to respond approval: ${response.statusText}`);
+  },
+};
diff --git a/ui/src/app/state/useNavigationState.ts b/ui/src/app/state/useNavigationState.ts
new file mode 100644
index 00000000..b6bbb739
--- /dev/null
+++ b/ui/src/app/state/useNavigationState.ts
@@ -0,0 +1,462 @@
+import { useCallback, useMemo } from "react";
+import { useLocation, useNavigate } from "react-router-dom";
+import type {
+  BreadcrumbItem,
+  LeftPanelView,
+  Selection,
+  WorkspaceSnapshot,
+} from "@/app/types";
+
+const sectionRootByView: Record<LeftPanelView, string> = {
+  projects: "/projects",
+  workspace: "/workspace",
+  workflow: "/workflows",
+  asset: "/assets",
+  agent: "/agents",
+};
+
+const buildWorkspaceFileSelection = (searchParams: URLSearchParams): Selection | null => {
+  const filePath = searchParams.get("file");
+  const fileKind = searchParams.get("fileKind");
+
+  if (!filePath || !fileKind) {
+    return null;
+  }
+
+  return {
+    objectType: "workspace-file",
+    objectId: filePath,
+    filePath,
+    fileKind:
+      fileKind === "yaml" ||
+      fileKind === "json" ||
+      fileKind === "python" ||
+      fileKind === "markdown" ||
+      fileKind === "text" ||
+      fileKind === "image"
+        ? fileKind
+        : "unknown",
+  };
+};
+
+const getLeftPanelViewFromPath = (pathname: string): LeftPanelView => {
+  if (pathname.startsWith("/workspace")) {
+    return "workspace";
+  }
+  if (pathname.startsWith("/workflows")) {
+    return "workflow";
+  }
+  if (pathname.startsWith("/assets")) {
+    return "asset";
+  }
+  if (pathname.startsWith("/agents")) {
+    return "agent";
+  }
+  return "projects";
+};
+
+const buildSelectionFromLocation = (
+  pathname: string,
+  searchParams: URLSearchParams,
+): Selection | null => {
+  const projectRunMatch = pathname.match(
+    /^\/projects\/([^/]+)\/experiments\/([^/]+)\/runs\/([^/]+)$/,
+  );
+  if (projectRunMatch) {
+    return {
+      objectType: "run",
+      objectId: decodeURIComponent(projectRunMatch[3]),
+    };
+  }
+
+  const experimentMatch = pathname.match(/^\/projects\/([^/]+)\/experiments\/([^/]+)$/);
+  if (experimentMatch) {
+    return {
+      objectType: "experiment",
+      objectId: decodeURIComponent(experimentMatch[2]),
+    };
+  }
+
+  const projectMatch = pathname.match(/^\/projects\/([^/]+)$/);
+  if (projectMatch) {
+    return {
+      objectType: "project",
+      objectId: decodeURIComponent(projectMatch[1]),
+    };
+  }
+
+  const workflowMatch = pathname.match(/^\/workflows\/([^/]+)$/);
+  if (workflowMatch) {
+    return {
+      objectType: "workflow",
+      objectId: decodeURIComponent(workflowMatch[1]),
+      workflowId: decodeURIComponent(workflowMatch[1]),
+    };
+  }
+
+  const assetMatch = pathname.match(/^\/assets\/([^/]+)$/);
+  if (assetMatch) {
+    return {
+      objectType: "asset",
+      objectId: decodeURIComponent(assetMatch[1]),
+    };
+  }
+
+  if (pathname === "/agents/new") {
+    return {
+      objectType: "agent",
+      objectId: "new",
+    };
+  }
+
+  const agentMatch = pathname.match(/^\/agents\/([^/]+)$/);
+  if (agentMatch) {
+    return {
+      objectType: "agent",
+      objectId: decodeURIComponent(agentMatch[1]),
+    };
+  }
+
+  if (pathname.startsWith("/workspace")) {
+    return buildWorkspaceFileSelection(searchParams);
+  }
+
+  return null;
+};
+
+const getSelectionPath = (selection: Selection | null, snapshot: WorkspaceSnapshot): string => {
+  if (!selection) {
+    return "/projects";
+  }
+
+  switch (selection.objectType) {
+    case "project":
+      return `/projects/${encodeURIComponent(selection.objectId)}`;
+    case "experiment": {
+      const experiment = snapshot.experiments.find((item) => item.id === selection.objectId);
+      if (!experiment) {
+        return "/projects";
+      }
+      return `/projects/${encodeURIComponent(experiment.projectId)}/experiments/${encodeURIComponent(experiment.id)}`;
+    }
+    case "run": {
+      const run = snapshot.runs.find((item) => item.id === selection.objectId);
+      if (!run) {
+        return "/projects";
+      }
+      return `/projects/${encodeURIComponent(run.projectId)}/experiments/${encodeURIComponent(run.experimentId)}/runs/${encodeURIComponent(run.id)}`;
+    }
+    case "workflow":
+      return `/workflows/${encodeURIComponent(selection.workflowId)}`;
+    case "asset":
+      return `/assets/${encodeURIComponent(selection.objectId)}`;
+    case "agent":
+      return selection.objectId === "new"
+        ? "/agents/new"
+        : `/agents/${encodeURIComponent(selection.objectId)}`;
+    case "workspace-file": {
+      const params = new URLSearchParams({
+        file: selection.filePath,
+        fileKind: selection.fileKind,
+      });
+      return `/workspace?${params.toString()}`;
+    }
+  }
+};
+
+const buildBreadcrumbs = (
+  selection: Selection | null,
+  snapshot: WorkspaceSnapshot,
+  leftPanelView: LeftPanelView,
+): BreadcrumbItem[] => {
+  if (!selection) {
+    if (leftPanelView === "projects") {
+      return [{ label: "Projects" }];
+    }
+    if (leftPanelView === "workflow") {
+      return [{ label: "Workflows" }];
+    }
+    if (leftPanelView === "asset") {
+      return [{ label: "Assets" }];
+    }
+    if (leftPanelView === "agent") {
+      return [{ label: "Agents" }];
+    }
+    return [{ label: "Workspace" }];
+  }
+
+  switch (selection.objectType) {
+    case "project": {
+      const project = snapshot.projects.find((item) => item.id === selection.objectId);
+      return [
+        { label: "Projects", to: "/projects" },
+        { label: project?.name ?? selection.objectId },
+      ];
+    }
+    case "experiment": {
+      const experiment = snapshot.experiments.find((item) => item.id === selection.objectId);
+      const project = experiment
+        ? snapshot.projects.find((item) => item.id === experiment.projectId)
+        : null;
+      return [
+        { label: "Projects", to: "/projects" },
+        ...(project
+          ? [
+              {
+                label: project.name,
+                to: `/projects/${encodeURIComponent(project.id)}`,
+              },
+            ]
+          : []),
+        { label: experiment?.name ?? selection.objectId },
+      ];
+    }
+    case "run": {
+      const run = snapshot.runs.find((item) => item.id === selection.objectId);
+      const experiment = run
+        ? snapshot.experiments.find((item) => item.id === run.experimentId)
+        : null;
+      const project = run ? snapshot.projects.find((item) => item.id === run.projectId) : null;
+      return [
+        { label: "Projects", to: "/projects" },
+        ...(project
+          ? [
+              {
+                label: project.name,
+                to: `/projects/${encodeURIComponent(project.id)}`,
+              },
+            ]
+          : []),
+        ...(project && experiment
+          ? [
+              {
+                label: experiment.name,
+                to: `/projects/${encodeURIComponent(project.id)}/experiments/${encodeURIComponent(experiment.id)}`,
+              },
+            ]
+          : []),
+        { label: run?.name ?? selection.objectId },
+      ];
+    }
+    case "workflow": {
+      const workflow = snapshot.workflows.find((item) => item.id === selection.workflowId);
+      return [
+        { label: "Workflows", to: "/workflows" },
+        { label: workflow?.name ?? selection.workflowId },
+      ];
+    }
+    case "asset": {
+      const asset = snapshot.assets.find((item) => item.id === selection.objectId);
+      return [{ label: "Assets", to: "/assets" }, { label: asset?.name ?? selection.objectId }];
+    }
+    case "agent": {
+      if (selection.objectId === "new") {
+        return [{ label: "Agents", to: "/agents" }, { label: "New Goal" }];
+      }
+
+      const session = snapshot.agentSessions.find((item) => item.id === selection.objectId);
+      return [
+        { label: "Agents", to: "/agents" },
+        { label: session?.goalDescription ?? selection.objectId },
+      ];
+    }
+    case "workspace-file":
+      return [
+        { label: "Workspace", to: "/workspace" },
+        { label: selection.filePath.split("/").pop() ?? selection.filePath },
+      ];
+  }
+};
+
+const buildContextMeta = (
+  selection: Selection | null,
+  snapshot: WorkspaceSnapshot,
+  leftPanelView: LeftPanelView,
+): { title: string; subtitle: string; statusLabel?: string } => {
+  if (!selection) {
+    switch (leftPanelView) {
+      case "projects":
+        return {
+          title: "Projects",
+          subtitle: "Browse projects, experiments, and runs from a single hierarchy.",
+        };
+      case "workspace":
+        return {
+          title: "Workspace",
+          subtitle: "Explore source files and workspace artifacts.",
+        };
+      case "workflow":
+        return {
+          title: "Workflows",
+          subtitle: "Inspect workflow definitions and graph structure.",
+        };
+      case "asset":
+        return {
+          title: "Assets",
+          subtitle: "Review generated and imported project assets.",
+        };
+      case "agent":
+        return {
+          title: "Agents",
+          subtitle: "Manage agent sessions and goals.",
+        };
+    }
+  }
+
+  switch (selection.objectType) {
+    case "project": {
+      const project = snapshot.projects.find((item) => item.id === selection.objectId);
+      return {
+        title: project?.name ?? selection.objectId,
+        subtitle: project?.summary || "Project overview",
+        statusLabel: project?.status,
+      };
+    }
+    case "experiment": {
+      const experiment = snapshot.experiments.find((item) => item.id === selection.objectId);
+      return {
+        title: experiment?.name ?? selection.objectId,
+        subtitle: experiment?.workflowFile || experiment?.summary || "Experiment overview",
+        statusLabel: experiment?.status,
+      };
+    }
+    case "run": {
+      const run = snapshot.runs.find((item) => item.id === selection.objectId);
+      return {
+        title: run?.name ?? selection.objectId,
+        subtitle: run?.summary || "Run overview",
+        statusLabel: run?.status,
+      };
+    }
+    case "workflow": {
+      const workflow = snapshot.workflows.find((item) => item.id === selection.workflowId);
+      return {
+        title: workflow?.name ?? selection.workflowId,
+        subtitle: workflow?.summary || "Workflow overview",
+        statusLabel: workflow?.status,
+      };
+    }
+    case "asset": {
+      const asset = snapshot.assets.find((item) => item.id === selection.objectId);
+      return {
+        title: asset?.name ?? selection.objectId,
+        subtitle: asset?.summary || "Asset overview",
+        statusLabel: asset?.status,
+      };
+    }
+    case "agent": {
+      const session = snapshot.agentSessions.find((item) => item.id === selection.objectId);
+      return {
+        title: selection.objectId === "new" ? "New Goal" : session?.goalDescription ?? selection.objectId,
+        subtitle:
+          selection.objectId === "new"
+            ? "Create a new agent session."
+            : `${session?.eventCount ?? 0} events`,
+        statusLabel: session?.status,
+      };
+    }
+    case "workspace-file":
+      return {
+        title: selection.filePath.split("/").pop() ?? selection.filePath,
+        subtitle: selection.filePath,
+      };
+  }
+};
+
+export interface NavigationState {
+  breadcrumbs: BreadcrumbItem[];
+  canNavigateUp: boolean;
+  contextStatusLabel?: string;
+  contextSubtitle: string;
+  contextTitle: string;
+  leftPanelView: LeftPanelView;
+  selection: Selection | null;
+  navigateUp: () => void;
+  setLeftPanelView: (view: LeftPanelView) => void;
+  setSelection: (selection: Selection | null) => void;
+}
+
+export const useNavigationState = (snapshot: WorkspaceSnapshot): NavigationState => {
+  const location = useLocation();
+  const navigate = useNavigate();
+
+  const searchParams = useMemo(
+    () => new URLSearchParams(location.search),
+    [location.search],
+  );
+
+  const leftPanelView = useMemo(
+    () => getLeftPanelViewFromPath(location.pathname),
+    [location.pathname],
+  );
+
+  const selection = useMemo(
+    () => buildSelectionFromLocation(location.pathname, searchParams),
+    [location.pathname, searchParams],
+  );
+
+  const breadcrumbs = useMemo(
+    () => buildBreadcrumbs(selection, snapshot, leftPanelView),
+    [selection, snapshot, leftPanelView],
+  );
+
+  const contextMeta = useMemo(
+    () => buildContextMeta(selection, snapshot, leftPanelView),
+    [selection, snapshot, leftPanelView],
+  );
+
+  const setSelection = useCallback(
+    (nextSelection: Selection | null): void => {
+      navigate(getSelectionPath(nextSelection, snapshot));
+    },
+    [navigate, snapshot],
+  );
+
+  const setLeftPanelView = useCallback(
+    (view: LeftPanelView): void => {
+      if (selection) {
+        if (view === "projects" && ["project", "experiment", "run"].includes(selection.objectType)) {
+          navigate(getSelectionPath(selection, snapshot));
+          return;
+        }
+        if (view === "workflow" && selection.objectType === "workflow") {
+          navigate(getSelectionPath(selection, snapshot));
+          return;
+        }
+        if (view === "asset" && selection.objectType === "asset") {
+          navigate(getSelectionPath(selection, snapshot));
+          return;
+        }
+        if (view === "agent" && selection.objectType === "agent") {
+          navigate(getSelectionPath(selection, snapshot));
+          return;
+        }
+        if (view === "workspace" && selection.objectType === "workspace-file") {
+          navigate(getSelectionPath(selection, snapshot));
+          return;
+        }
+      }
+
+      navigate(sectionRootByView[view]);
+    },
+    [navigate, selection, snapshot],
+  );
+
+  const navigateUp = useCallback((): void => {
+    const parent = breadcrumbs[breadcrumbs.length - 2];
+    navigate(parent?.to ?? sectionRootByView[leftPanelView]);
+  }, [breadcrumbs, navigate, leftPanelView]);
+
+  return {
+    breadcrumbs,
+    canNavigateUp: breadcrumbs.length > 1,
+    contextStatusLabel: contextMeta.statusLabel,
+    contextSubtitle: contextMeta.subtitle,
+    contextTitle: contextMeta.title,
+    leftPanelView,
+    selection,
+    navigateUp,
+    setLeftPanelView,
+    setSelection,
+  };
+};
diff --git a/ui/src/app/state/useUrlState.ts b/ui/src/app/state/useUrlState.ts
index eb2307dc..d73132ad 100644
--- a/ui/src/app/state/useUrlState.ts
+++ b/ui/src/app/state/useUrlState.ts
@@ -1,23 +1,23 @@
 import { useCallback, useMemo } from "react";
 import { useSearchParams } from "react-router-dom";
 import type {
+  AgentSelection,
+  FileKind,
   LeftPanelView,
   Selection,
   SemanticObjectType,
-  WorkspaceFileSelection,
   WorkflowSelection,
-  FileKind,
+  WorkspaceFileSelection,
 } from "@/app/types";
 
-const DEFAULT_VIEW: LeftPanelView = "project";
+const DEFAULT_VIEW: LeftPanelView = "projects";
 
 const viewParamValues: LeftPanelView[] = [
   "workspace",
-  "project",
-  "experiment",
-  "run",
+  "projects",
   "asset",
   "workflow",
+  "agent",
 ];
 
 const objectTypeValues: SemanticObjectType[] = [
@@ -27,6 +27,7 @@ const objectTypeValues: SemanticObjectType[] = [
   "asset",
   "workflow",
   "workspace-file",
+  "agent",
 ];
 
 const fileKindValues: FileKind[] = [
@@ -88,6 +89,11 @@ const buildSelection = (
     return workflowSelection;
   }
 
+  if (objectType === "agent") {
+    const agentSelection: AgentSelection = { objectType: "agent", objectId };
+    return agentSelection;
+  }
+
   return {
     objectType,
     objectId,
diff --git a/ui/src/app/state/useWorkspaceState.ts b/ui/src/app/state/useWorkspaceState.ts
index f1fa03a8..4980d59c 100644
--- a/ui/src/app/state/useWorkspaceState.ts
+++ b/ui/src/app/state/useWorkspaceState.ts
@@ -1,8 +1,9 @@
 import { useCallback, useEffect, useState } from "react";
-import type { WorkspaceSnapshot } from "@/app/types";
 import {
+  agentApi,
   buildEmptySnapshot,
   emptyConsoleEntries,
+  mapAgentSessions,
   mapAssets,
   mapExperiments,
   mapProjects,
@@ -11,6 +12,7 @@ import {
   mapWorkspaceTree,
   workspaceApi,
 } from "@/app/state/api";
+import type { WorkspaceSnapshot } from "@/app/types";
 
 export type WorkspaceStatus = "idle" | "loading" | "ready" | "error";
 
@@ -58,7 +60,6 @@ const buildSnapshot = async (): Promise<WorkspaceSnapshot> => {
     mapRuns(item.projectId, item.experimentId, item.runs),
   );
 
-
   const projectAssets = await Promise.all(
     projectsResponse.map(async (project) => {
       try {
@@ -71,21 +72,27 @@ const buildSnapshot = async (): Promise<WorkspaceSnapshot> => {
     }),
   );
 
-  const allAssets = [
-    ...mapAssets(await workspaceApi.getAssets()),
-    ...projectAssets.flat(),
-  ];
+  const allAssets = [...mapAssets(await workspaceApi.getAssets()), ...projectAssets.flat()];
 
-  const assetSummaries = Array.from(new Map(allAssets.map(item => [item.id, item])).values());
+  const assetSummaries = Array.from(new Map(allAssets.map((item) => [item.id, item])).values());
   const rawExperiments = experimentsByProject.flatMap((item) => item.experiments);
   const workflowSummaries = mapWorkflows(experimentSummaries, rawExperiments);
 
+  let agentSessions: WorkspaceSnapshot["agentSessions"] = [];
+  try {
+    const rawSessions = await agentApi.listSessions();
+    agentSessions = mapAgentSessions(rawSessions);
+  } catch (err) {
+    console.warn("Agent sessions unavailable:", err);
+  }
+
   return {
     projects: projectSummaries,
     experiments: experimentSummaries,
     runs: runSummaries,
     assets: assetSummaries,
     workflows: workflowSummaries,
+    agentSessions,
     workspaceRoot,
     consoleEntries: emptyConsoleEntries(),
   };
diff --git a/ui/src/app/types.ts b/ui/src/app/types.ts
index 9963571e..7d5df50b 100644
--- a/ui/src/app/types.ts
+++ b/ui/src/app/types.ts
@@ -1,4 +1,9 @@
-export type LeftPanelView = "workspace" | "project" | "experiment" | "run" | "asset" | "workflow";
+export type LeftPanelView =
+  | "workspace"
+  | "projects"
+  | "asset"
+  | "workflow"
+  | "agent";
 
 export type SemanticObjectType =
   | "project"
@@ -6,7 +11,8 @@ export type SemanticObjectType =
   | "run"
   | "asset"
   | "workflow"
-  | "workspace-file";
+  | "workspace-file"
+  | "agent";
 
 export type BaseObjectType = "project" | "experiment" | "run" | "asset";
 
@@ -14,13 +20,7 @@ export type PanelKind = "editor" | "viewer" | "inspector";
 
 export type FileKind = "yaml" | "json" | "python" | "markdown" | "text" | "image" | "unknown";
 
-export type ContentType =
-  | "workflow-graph"
-  | "metadata"
-  | "log"
-  | "text"
-  | "metrics"
-  | "image";
+export type ContentType = "workflow-graph" | "metadata" | "log" | "text" | "metrics" | "image";
 
 export type JsonValue = string | number | boolean | null | JsonObject | JsonValue[];
 
@@ -36,26 +36,30 @@ export type SemanticStatus =
   | "running"
   | "succeeded"
   | "failed"
-  | "failed"
   | "cancelled"
   | "skipped";
 
-import type { ProjectCreateRequest } from "../api/generated/models/ProjectCreateRequest";
 import type { ExperimentCreateRequest } from "../api/generated/models/ExperimentCreateRequest";
+import type { ProjectCreateRequest } from "../api/generated/models/ProjectCreateRequest";
 import type { RunCreateRequest } from "../api/generated/models/RunCreateRequest";
 
-export type { ProjectCreateRequest, ExperimentCreateRequest, RunCreateRequest };
+export type { ExperimentCreateRequest, ProjectCreateRequest, RunCreateRequest };
 
-import type { ProjectResponse } from "../api/generated/models/ProjectResponse";
-import type { ExperimentResponse } from "../api/generated/models/ExperimentResponse";
-import type { RunResponse } from "../api/generated/models/RunResponse";
-import type { AssetResponse } from "../api/generated/models/AssetResponse";
+import type { AgentSessionResponse } from "../api/generated/models/AgentSessionResponse";
 import type { AssetFileResponse } from "../api/generated/models/AssetFileResponse";
-import type { WorkflowSnapshotResponse } from "../api/generated/models/WorkflowSnapshotResponse";
-import type { ContextSnapshotResponse } from "../api/generated/models/ContextSnapshotResponse";
 import type { AssetRefResponse } from "../api/generated/models/AssetRefResponse";
 import type { AssetRefsResponse } from "../api/generated/models/AssetRefsResponse";
+import type { AssetResponse } from "../api/generated/models/AssetResponse";
+import type { CacheClearResponse } from "../api/generated/models/CacheClearResponse";
+import type { CacheStatsResponse } from "../api/generated/models/CacheStatsResponse";
+import type { ContextSnapshotResponse } from "../api/generated/models/ContextSnapshotResponse";
+import type { ExperimentResponse } from "../api/generated/models/ExperimentResponse";
+import type { ProjectResponse } from "../api/generated/models/ProjectResponse";
+import type { RunResponse } from "../api/generated/models/RunResponse";
 import type { RunSummary as ApiRunSummaryModel } from "../api/generated/models/RunSummary";
+import type { SessionEventResponse } from "../api/generated/models/SessionEventResponse";
+import type { TaskSnapshotResponse } from "../api/generated/models/TaskSnapshotResponse";
+import type { WorkflowSnapshotResponse } from "../api/generated/models/WorkflowSnapshotResponse";
 
 // Re-export as Api*Response for compatibility
 export type ApiProjectResponse = ProjectResponse;
@@ -68,6 +72,11 @@ export type ApiContextSnapshot = ContextSnapshotResponse;
 export type ApiAssetRef = AssetRefResponse;
 export type ApiAssetRefs = AssetRefsResponse;
 export type ApiRunSummary = ApiRunSummaryModel;
+export type ApiTaskSnapshot = TaskSnapshotResponse;
+export type ApiCacheStats = CacheStatsResponse;
+export type ApiCacheClear = CacheClearResponse;
+export type ApiAgentSession = AgentSessionResponse;
+export type ApiSessionEvent = SessionEventResponse;
 
 export interface ProjectSummary {
   id: string;
@@ -95,6 +104,7 @@ export interface RunSummary {
   updatedAt: string;
   projectId: string;
   experimentId: string;
+  executorInfo: Record<string, string>;
 }
 
 export interface AssetSummary {
@@ -118,6 +128,14 @@ export interface WorkflowSummary {
   graph?: WorkflowGraph;
 }
 
+export interface AgentSessionSummary {
+  id: string;
+  goalDescription: string;
+  status: SemanticStatus;
+  createdAt: string;
+  eventCount: number;
+}
+
 export interface WorkflowNodeMetadata {
   nodeId: string;
   label: string;
@@ -167,6 +185,7 @@ export interface WorkspaceSnapshot {
   runs: RunSummary[];
   assets: AssetSummary[];
   workflows: WorkflowSummary[];
+  agentSessions: AgentSessionSummary[];
   workspaceRoot: WorkspaceTreeNode | null;
   consoleEntries: ConsoleEntry[];
 }
@@ -189,19 +208,28 @@ export interface WorkspaceFileSelection {
   objectId: string;
 }
 
-export type Selection = ObjectSelection | WorkflowSelection | WorkspaceFileSelection;
+export interface AgentSelection {
+  objectType: "agent";
+  objectId: string; // session_id, or "new" for the goal-input state
+}
+
+export type Selection =
+  | ObjectSelection
+  | WorkflowSelection
+  | WorkspaceFileSelection
+  | AgentSelection;
 
 export type InspectorTarget =
   | {
-    kind: "object";
-    objectType: SemanticObjectType;
-    objectId: string;
-  }
+      kind: "object";
+      objectType: SemanticObjectType;
+      objectId: string;
+    }
   | {
-    kind: "workflow-node";
-    workflowId: string;
-    nodeId: string;
-  };
+      kind: "workflow-node";
+      workflowId: string;
+      nodeId: string;
+    };
 
 export interface RendererKey {
   objectType: SemanticObjectType;
@@ -219,3 +247,7 @@ export interface RendererProps {
   onRefresh: () => void;
 }
 
+export interface BreadcrumbItem {
+  label: string;
+  to?: string;
+}
diff --git a/ui/src/components/FileExplorer.tsx b/ui/src/components/FileExplorer.tsx
index dd10355c..d550a5eb 100644
--- a/ui/src/components/FileExplorer.tsx
+++ b/ui/src/components/FileExplorer.tsx
@@ -1,31 +1,18 @@
 /**
  * FileExplorer - Workspace file explorer
- * 
+ *
  * Low-level, file-oriented navigation surface
  * Presents workspace as hierarchical, collapsible file structure
  * Does NOT impose semantic meaning beyond file system structure
- * 
+ *
  * Separated from semantic views (Project, Experiment, Run, Asset)
  */
 
-import React, { useState, useEffect } from "react";
-import {
-  MoreVertical,
-  Copy,
-  Trash2,
-  RefreshCw,
-  ChevronRight,
-} from "lucide-react";
-import { Tree, type TreeNodeProps } from "@/components/ui/tree";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu";
+import { Copy, RefreshCw, Trash2 } from "lucide-react";
+import React, { useCallback, useEffect, useState } from "react";
 import { Button } from "@/components/ui/button";
 import { ScrollArea } from "@/components/ui/scroll-area";
+import { Tree, type TreeNodeProps } from "@/components/ui/tree";
 import { cn } from "@/lib/utils";
 
 interface FileExplorerProps {
@@ -45,25 +32,25 @@ interface ExplorerContextMenuProps {
 /**
  * ExplorerContextMenu - Right-click menu for file operations
  */
-const ExplorerContextMenu = ({
-  node,
-  onCopy,
-  onDelete,
-  event,
-}: ExplorerContextMenuProps) => {
+const ExplorerContextMenu = ({ node, onCopy, onDelete, event }: ExplorerContextMenuProps) => {
   const position = { x: event.clientX, y: event.clientY };
 
   return (
     <div
       className="fixed bg-popover border border-border rounded-md shadow-md z-50 min-w-[150px]"
+      role="menu"
       style={{
         top: `${position.y}px`,
         left: `${position.x}px`,
       }}
-      onClick={e => e.stopPropagation()}
+      onClick={(e) => e.stopPropagation()}
+      onKeyDown={(e) => {
+        if (e.key === "Escape") e.stopPropagation();
+      }}
     >
       <div className="py-1">
         <button
+          type="button"
           className="w-full text-left px-2 py-1.5 text-sm hover:bg-accent flex items-center gap-2"
           onClick={() => {
             onCopy?.(node.path);
@@ -73,6 +60,7 @@ const ExplorerContextMenu = ({
           Copy path
         </button>
         <button
+          type="button"
           className="w-full text-left px-2 py-1.5 text-sm hover:bg-accent text-destructive flex items-center gap-2"
           onClick={() => {
             onDelete?.(node.path);
@@ -86,19 +74,34 @@ const ExplorerContextMenu = ({
   );
 };
 
+const transformToTreeNodes = (items: unknown[]): TreeNodeProps[] => {
+  return items.map((rawItem) => {
+    const item = rawItem as Record<string, unknown>;
+    return {
+      id: (item.id as string) || (item.path as string),
+      name: item.name as string,
+      path: item.path as string,
+      kind: item.type === "folder" ? "folder" : ("file" as "folder" | "file"),
+      children: Array.isArray(item.children) ? transformToTreeNodes(item.children) : undefined,
+      metadata: {
+        size: item.size,
+        modified: item.modified,
+        type: item.type,
+      },
+    };
+  });
+};
+
 /**
  * FileExplorer - Main component
- * 
+ *
  * Provides pure file-system tree navigation
  * - No semantic interpretation of files
  * - No project/experiment/run context
  * - Pure hierarchical file structure
  */
 export const FileExplorer = React.forwardRef<HTMLDivElement, FileExplorerProps>(
-  (
-    { onSelectFile, onSelectFolder, rootPath = "/", className },
-    ref
-  ) => {
+  ({ onSelectFile, onSelectFolder, rootPath = "/", className }, ref) => {
     const [treeNodes, setTreeNodes] = useState<TreeNodeProps[]>([]);
     const [loading, setLoading] = useState(false);
     const [error, setError] = useState<string | null>(null);
@@ -106,22 +109,16 @@ export const FileExplorer = React.forwardRef<HTMLDivElement, FileExplorerProps>(
       node: TreeNodeProps;
       event: React.MouseEvent;
     } | null>(null);
-    const [selectedNodeId, setSelectedNodeId] = useState<string | null>(null);
 
-    // Load root workspace files
-    useEffect(() => {
-      loadWorkspaceTree();
-    }, [rootPath]);
-
-    const loadWorkspaceTree = async () => {
+    const loadWorkspaceTree = useCallback(async () => {
       try {
         setLoading(true);
         setError(null);
 
         // Fetch the workspace tree from API
         // This should return the pure file-system structure
-        const response = await fetch("/api/workspace/files?path=" + encodeURIComponent(rootPath));
-        
+        const response = await fetch(`/api/workspace/files?path=${encodeURIComponent(rootPath)}`);
+
         if (!response.ok) {
           throw new Error(`Failed to load workspace: ${response.statusText}`);
         }
@@ -135,26 +132,14 @@ export const FileExplorer = React.forwardRef<HTMLDivElement, FileExplorerProps>(
       } finally {
         setLoading(false);
       }
-    };
+    }, [rootPath]);
 
-    const transformToTreeNodes = (items: any[]): TreeNodeProps[] => {
-      return items.map(item => ({
-        id: item.id || item.path,
-        name: item.name,
-        path: item.path,
-        kind: item.type === "folder" ? "folder" : "file",
-        children: item.children ? transformToTreeNodes(item.children) : undefined,
-        metadata: {
-          size: item.size,
-          modified: item.modified,
-          type: item.type,
-        },
-      }));
-    };
+    // Load root workspace files
+    useEffect(() => {
+      loadWorkspaceTree();
+    }, [loadWorkspaceTree]);
 
     const handleSelectNode = (node: TreeNodeProps) => {
-      setSelectedNodeId(node.id);
-
       if (node.kind === "file") {
         onSelectFile?.(node.path, node);
       } else {
@@ -186,12 +171,7 @@ export const FileExplorer = React.forwardRef<HTMLDivElement, FileExplorerProps>(
             <p className="font-semibold">Error loading workspace</p>
             <p className="text-xs">{error}</p>
           </div>
-          <Button
-            variant="outline"
-            size="sm"
-            onClick={loadWorkspaceTree}
-            className="w-full"
-          >
+          <Button variant="outline" size="sm" onClick={loadWorkspaceTree} className="w-full">
             <RefreshCw className="h-3.5 w-3.5 mr-1" />
             Retry
           </Button>
@@ -200,13 +180,7 @@ export const FileExplorer = React.forwardRef<HTMLDivElement, FileExplorerProps>(
     }
 
     return (
-      <div
-        ref={ref}
-        className={cn(
-          "flex flex-col h-full bg-background",
-          className
-        )}
-      >
+      <div ref={ref} className={cn("flex flex-col h-full bg-background", className)}>
         {/* Header */}
         <div className="flex items-center justify-between px-4 py-3 border-b">
           <h3 className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">
@@ -220,9 +194,7 @@ export const FileExplorer = React.forwardRef<HTMLDivElement, FileExplorerProps>(
             disabled={loading}
             title="Refresh"
           >
-            <RefreshCw
-              className={cn("h-3.5 w-3.5", loading && "animate-spin")}
-            />
+            <RefreshCw className={cn("h-3.5 w-3.5", loading && "animate-spin")} />
           </Button>
         </div>
 
@@ -233,15 +205,9 @@ export const FileExplorer = React.forwardRef<HTMLDivElement, FileExplorerProps>(
               <div className="text-xs text-muted-foreground">Loading...</div>
             </div>
           ) : treeNodes.length === 0 ? (
-            <div className="text-xs text-muted-foreground p-4">
-              No files or folders found
-            </div>
+            <div className="text-xs text-muted-foreground p-4">No files or folders found</div>
           ) : (
-            <Tree
-              nodes={treeNodes}
-              onSelect={handleSelectNode}
-              onContextMenu={handleContextMenu}
-            />
+            <Tree nodes={treeNodes} onSelect={handleSelectNode} onContextMenu={handleContextMenu} />
           )}
         </ScrollArea>
 
@@ -256,7 +222,7 @@ export const FileExplorer = React.forwardRef<HTMLDivElement, FileExplorerProps>(
         )}
       </div>
     );
-  }
+  },
 );
 
 FileExplorer.displayName = "FileExplorer";
diff --git a/ui/src/components/previews/MarkdownPreview.tsx b/ui/src/components/previews/MarkdownPreview.tsx
new file mode 100644
index 00000000..1f5a52fd
--- /dev/null
+++ b/ui/src/components/previews/MarkdownPreview.tsx
@@ -0,0 +1,11 @@
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import type { FilePreviewContentProps } from "@/lib/file-preview-plugins";
+
+export const MarkdownPreview = ({ content }: FilePreviewContentProps): JSX.Element => {
+  return (
+    <article className="prose prose-sm max-w-none px-4 py-3">
+      <ReactMarkdown remarkPlugins={[remarkGfm]}>{content}</ReactMarkdown>
+    </article>
+  );
+};
diff --git a/ui/src/components/previews/WorkflowPreview.tsx b/ui/src/components/previews/WorkflowPreview.tsx
new file mode 100644
index 00000000..e7fb7d76
--- /dev/null
+++ b/ui/src/components/previews/WorkflowPreview.tsx
@@ -0,0 +1,20 @@
+import type { FilePreviewContentProps } from "@/lib/file-preview-plugins";
+
+export const WorkflowPreview = ({ content, name, path }: FilePreviewContentProps): JSX.Element => {
+  return (
+    <div className="space-y-2 p-3">
+      <div className="text-xs text-muted-foreground">Workflow preview</div>
+      <div className="rounded border border-border bg-muted/20 px-3 py-2 text-xs">
+        <p>
+          <strong>Name:</strong> {name}
+        </p>
+        <p>
+          <strong>Path:</strong> {path}
+        </p>
+      </div>
+      <pre className="max-h-[420px] overflow-auto rounded border border-border bg-background p-3 text-xs">
+        {content}
+      </pre>
+    </div>
+  );
+};
diff --git a/ui/src/components/ui/badge.tsx b/ui/src/components/ui/badge.tsx
index f000e3ef..0d2d9cb6 100644
--- a/ui/src/components/ui/badge.tsx
+++ b/ui/src/components/ui/badge.tsx
@@ -1,15 +1,14 @@
-import * as React from "react"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 const badgeVariants = cva(
   "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
   {
     variants: {
       variant: {
-        default:
-          "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+        default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
         secondary:
           "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
         destructive:
@@ -20,17 +19,15 @@ const badgeVariants = cva(
     defaultVariants: {
       variant: "default",
     },
-  }
-)
+  },
+);
 
 export interface BadgeProps
   extends React.HTMLAttributes<HTMLDivElement>,
     VariantProps<typeof badgeVariants> {}
 
 function Badge({ className, variant, ...props }: BadgeProps) {
-  return (
-    <div className={cn(badgeVariants({ variant }), className)} {...props} />
-  )
+  return <div className={cn(badgeVariants({ variant }), className)} {...props} />;
 }
 
-export { Badge, badgeVariants }
+export { Badge, badgeVariants };
diff --git a/ui/src/components/ui/button.tsx b/ui/src/components/ui/button.tsx
index 21409a06..ced02c50 100644
--- a/ui/src/components/ui/button.tsx
+++ b/ui/src/components/ui/button.tsx
@@ -1,8 +1,8 @@
-import * as React from "react"
-import { Slot } from "@radix-ui/react-slot"
-import { cva, type VariantProps } from "class-variance-authority"
+import { Slot } from "@radix-ui/react-slot";
+import { cva, type VariantProps } from "class-variance-authority";
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 const buttonVariants = cva(
   "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
@@ -14,10 +14,8 @@ const buttonVariants = cva(
           "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
         outline:
           "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
-        secondary:
-          "bg-secondary text-secondary-foreground hover:bg-secondary/80",
-        ghost:
-          "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
         link: "text-primary underline-offset-4 hover:underline",
       },
       size: {
@@ -33,8 +31,8 @@ const buttonVariants = cva(
       variant: "default",
       size: "default",
     },
-  }
-)
+  },
+);
 
 function Button({
   className,
@@ -44,9 +42,9 @@ function Button({
   ...props
 }: React.ComponentProps<"button"> &
   VariantProps<typeof buttonVariants> & {
-    asChild?: boolean
+    asChild?: boolean;
   }) {
-  const Comp = asChild ? Slot : "button"
+  const Comp = asChild ? Slot : "button";
 
   return (
     <Comp
@@ -54,7 +52,7 @@ function Button({
       className={cn(buttonVariants({ variant, size, className }))}
       {...props}
     />
-  )
+  );
 }
 
-export { Button, buttonVariants }
+export { Button, buttonVariants };
diff --git a/ui/src/components/ui/card.tsx b/ui/src/components/ui/card.tsx
index 681ad980..f03935ce 100644
--- a/ui/src/components/ui/card.tsx
+++ b/ui/src/components/ui/card.tsx
@@ -1,6 +1,6 @@
-import * as React from "react"
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 function Card({ className, ...props }: React.ComponentProps<"div">) {
   return (
@@ -8,11 +8,11 @@ function Card({ className, ...props }: React.ComponentProps<"div">) {
       data-slot="card"
       className={cn(
         "bg-card text-card-foreground flex flex-col gap-6 rounded-xl border py-6 shadow-sm",
-        className
+        className,
       )}
       {...props}
     />
-  )
+  );
 }
 
 function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
@@ -21,11 +21,11 @@ function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
       data-slot="card-header"
       className={cn(
         "@container/card-header grid auto-rows-min grid-rows-[auto_auto] items-start gap-2 px-6 has-data-[slot=card-action]:grid-cols-[1fr_auto] [.border-b]:pb-6",
-        className
+        className,
       )}
       {...props}
     />
-  )
+  );
 }
 
 function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
@@ -35,7 +35,7 @@ function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
       className={cn("leading-none font-semibold", className)}
       {...props}
     />
-  )
+  );
 }
 
 function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
@@ -45,30 +45,21 @@ function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
       className={cn("text-muted-foreground text-sm", className)}
       {...props}
     />
-  )
+  );
 }
 
 function CardAction({ className, ...props }: React.ComponentProps<"div">) {
   return (
     <div
       data-slot="card-action"
-      className={cn(
-        "col-start-2 row-span-2 row-start-1 self-start justify-self-end",
-        className
-      )}
+      className={cn("col-start-2 row-span-2 row-start-1 self-start justify-self-end", className)}
       {...props}
     />
-  )
+  );
 }
 
 function CardContent({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="card-content"
-      className={cn("px-6", className)}
-      {...props}
-    />
-  )
+  return <div data-slot="card-content" className={cn("px-6", className)} {...props} />;
 }
 
 function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
@@ -78,15 +69,7 @@ function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
       className={cn("flex items-center px-6 [.border-t]:pt-6", className)}
       {...props}
     />
-  )
+  );
 }
 
-export {
-  Card,
-  CardHeader,
-  CardFooter,
-  CardTitle,
-  CardAction,
-  CardDescription,
-  CardContent,
-}
+export { Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle };
diff --git a/ui/src/components/ui/dialog.tsx b/ui/src/components/ui/dialog.tsx
index daf6bf42..1b63d80f 100644
--- a/ui/src/components/ui/dialog.tsx
+++ b/ui/src/components/ui/dialog.tsx
@@ -1,32 +1,23 @@
-import * as React from "react"
-import * as DialogPrimitive from "@radix-ui/react-dialog"
-import { XIcon } from "lucide-react"
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import { XIcon } from "lucide-react";
+import type * as React from "react";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
 
-import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
-
-function Dialog({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Root>) {
-  return <DialogPrimitive.Root data-slot="dialog" {...props} />
+function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>) {
+  return <DialogPrimitive.Root data-slot="dialog" {...props} />;
 }
 
-function DialogTrigger({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
-  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />
+function DialogTrigger({ ...props }: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
+  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />;
 }
 
-function DialogPortal({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Portal>) {
-  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />
+function DialogPortal({ ...props }: React.ComponentProps<typeof DialogPrimitive.Portal>) {
+  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />;
 }
 
-function DialogClose({
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Close>) {
-  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />
+function DialogClose({ ...props }: React.ComponentProps<typeof DialogPrimitive.Close>) {
+  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />;
 }
 
 function DialogOverlay({
@@ -38,11 +29,11 @@ function DialogOverlay({
       data-slot="dialog-overlay"
       className={cn(
         "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
-        className
+        className,
       )}
       {...props}
     />
-  )
+  );
 }
 
 function DialogContent({
@@ -51,7 +42,7 @@ function DialogContent({
   showCloseButton = true,
   ...props
 }: React.ComponentProps<typeof DialogPrimitive.Content> & {
-  showCloseButton?: boolean
+  showCloseButton?: boolean;
 }) {
   return (
     <DialogPortal data-slot="dialog-portal">
@@ -60,7 +51,7 @@ function DialogContent({
         data-slot="dialog-content"
         className={cn(
           "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 outline-none sm:max-w-lg",
-          className
+          className,
         )}
         {...props}
       >
@@ -76,7 +67,7 @@ function DialogContent({
         )}
       </DialogPrimitive.Content>
     </DialogPortal>
-  )
+  );
 }
 
 function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
@@ -86,7 +77,7 @@ function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
       className={cn("flex flex-col gap-2 text-center sm:text-left", className)}
       {...props}
     />
-  )
+  );
 }
 
 function DialogFooter({
@@ -95,15 +86,12 @@ function DialogFooter({
   children,
   ...props
 }: React.ComponentProps<"div"> & {
-  showCloseButton?: boolean
+  showCloseButton?: boolean;
 }) {
   return (
     <div
       data-slot="dialog-footer"
-      className={cn(
-        "flex flex-col-reverse gap-2 sm:flex-row sm:justify-end",
-        className
-      )}
+      className={cn("flex flex-col-reverse gap-2 sm:flex-row sm:justify-end", className)}
       {...props}
     >
       {children}
@@ -113,20 +101,17 @@ function DialogFooter({
         </DialogPrimitive.Close>
       )}
     </div>
-  )
+  );
 }
 
-function DialogTitle({
-  className,
-  ...props
-}: React.ComponentProps<typeof DialogPrimitive.Title>) {
+function DialogTitle({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Title>) {
   return (
     <DialogPrimitive.Title
       data-slot="dialog-title"
       className={cn("text-lg leading-none font-semibold", className)}
       {...props}
     />
-  )
+  );
 }
 
 function DialogDescription({
@@ -139,7 +124,7 @@ function DialogDescription({
       className={cn("text-muted-foreground text-sm", className)}
       {...props}
     />
-  )
+  );
 }
 
 export {
@@ -153,4 +138,4 @@ export {
   DialogPortal,
   DialogTitle,
   DialogTrigger,
-}
+};
diff --git a/ui/src/components/ui/dropdown-menu.tsx b/ui/src/components/ui/dropdown-menu.tsx
index 2bc84525..8da1643d 100644
--- a/ui/src/components/ui/dropdown-menu.tsx
+++ b/ui/src/components/ui/dropdown-menu.tsx
@@ -1,25 +1,25 @@
-import * as React from "react"
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu"
-import { Check, ChevronRight, Circle } from "lucide-react"
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { Check, Circle } from "lucide-react";
+import * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
-const DropdownMenu = DropdownMenuPrimitive.Root
+const DropdownMenu = DropdownMenuPrimitive.Root;
 
-const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger
+const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger;
 
-const DropdownMenuGroup = DropdownMenuPrimitive.Group
+const DropdownMenuGroup = DropdownMenuPrimitive.Group;
 
-const DropdownMenuPortal = DropdownMenuPrimitive.Portal
+const DropdownMenuPortal = DropdownMenuPrimitive.Portal;
 
-const DropdownMenuSub = DropdownMenuPrimitive.Sub
+const DropdownMenuSub = DropdownMenuPrimitive.Sub;
 
-const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup
+const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup;
 
 const DropdownMenuSubTrigger = React.forwardRef<
   React.ElementRef<typeof DropdownMenuPrimitive.SubTrigger>,
   React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> & {
-    inset?: boolean
+    inset?: boolean;
   }
 >(({ className, inset, ...props }, ref) => (
   <DropdownMenuPrimitive.SubTrigger
@@ -27,13 +27,12 @@ const DropdownMenuSubTrigger = React.forwardRef<
     className={cn(
       "flex cursor-pointer select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent",
       inset && "pl-8",
-      className
+      className,
     )}
     {...props}
   />
-))
-DropdownMenuSubTrigger.displayName =
-  DropdownMenuPrimitive.SubTrigger.displayName
+));
+DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName;
 
 const DropdownMenuSubContent = React.forwardRef<
   React.ElementRef<typeof DropdownMenuPrimitive.SubContent>,
@@ -43,13 +42,12 @@ const DropdownMenuSubContent = React.forwardRef<
     ref={ref}
     className={cn(
       "min-w-[8rem] overflow-hidden rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
-      className
+      className,
     )}
     {...props}
   />
-))
-DropdownMenuSubContent.displayName =
-  DropdownMenuPrimitive.SubContent.displayName
+));
+DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName;
 
 const DropdownMenuContent = React.forwardRef<
   React.ElementRef<typeof DropdownMenuPrimitive.Content>,
@@ -61,19 +59,18 @@ const DropdownMenuContent = React.forwardRef<
       sideOffset={sideOffset}
       className={cn(
         "min-w-[8rem] overflow-hidden rounded-md border border-border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
-        className
+        className,
       )}
       {...props}
     />
   </DropdownMenuPrimitive.Portal>
-))
-DropdownMenuContent.displayName =
-  DropdownMenuPrimitive.Content.displayName
+));
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
 
 const DropdownMenuItem = React.forwardRef<
   React.ElementRef<typeof DropdownMenuPrimitive.Item>,
   React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
-    inset?: boolean
+    inset?: boolean;
   }
 >(({ className, inset, ...props }, ref) => (
   <DropdownMenuPrimitive.Item
@@ -81,13 +78,12 @@ const DropdownMenuItem = React.forwardRef<
     className={cn(
       "relative flex cursor-pointer select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
       inset && "pl-8",
-      className
+      className,
     )}
     {...props}
   />
-))
-DropdownMenuItem.displayName =
-  DropdownMenuPrimitive.Item.displayName
+));
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
 
 const DropdownMenuCheckboxItem = React.forwardRef<
   React.ElementRef<typeof DropdownMenuPrimitive.CheckboxItem>,
@@ -97,7 +93,7 @@ const DropdownMenuCheckboxItem = React.forwardRef<
     ref={ref}
     className={cn(
       "relative flex cursor-pointer select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
-      className
+      className,
     )}
     checked={checked}
     {...props}
@@ -110,9 +106,8 @@ const DropdownMenuCheckboxItem = React.forwardRef<
 
     {children}
   </DropdownMenuPrimitive.CheckboxItem>
-))
-DropdownMenuCheckboxItem.displayName =
-  DropdownMenuPrimitive.CheckboxItem.displayName
+));
+DropdownMenuCheckboxItem.displayName = DropdownMenuPrimitive.CheckboxItem.displayName;
 
 const DropdownMenuRadioItem = React.forwardRef<
   React.ElementRef<typeof DropdownMenuPrimitive.RadioItem>,
@@ -122,7 +117,7 @@ const DropdownMenuRadioItem = React.forwardRef<
     ref={ref}
     className={cn(
       "relative flex cursor-pointer select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
-      className
+      className,
     )}
     {...props}
   >
@@ -134,28 +129,22 @@ const DropdownMenuRadioItem = React.forwardRef<
 
     {children}
   </DropdownMenuPrimitive.RadioItem>
-))
-DropdownMenuRadioItem.displayName =
-  DropdownMenuPrimitive.RadioItem.displayName
+));
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
 
 const DropdownMenuLabel = React.forwardRef<
   React.ElementRef<typeof DropdownMenuPrimitive.Label>,
   React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
-    inset?: boolean
+    inset?: boolean;
   }
 >(({ className, inset, ...props }, ref) => (
   <DropdownMenuPrimitive.Label
     ref={ref}
-    className={cn(
-      "px-2 py-1.5 text-sm font-semibold",
-      inset && "pl-8",
-      className
-    )}
+    className={cn("px-2 py-1.5 text-sm font-semibold", inset && "pl-8", className)}
     {...props}
   />
-))
-DropdownMenuLabel.displayName =
-  DropdownMenuPrimitive.Label.displayName
+));
+DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
 
 const DropdownMenuSeparator = React.forwardRef<
   React.ElementRef<typeof DropdownMenuPrimitive.Separator>,
@@ -166,35 +155,31 @@ const DropdownMenuSeparator = React.forwardRef<
     className={cn("-mx-1 my-1 h-px bg-muted", className)}
     {...props}
   />
-))
-DropdownMenuSeparator.displayName =
-  DropdownMenuPrimitive.Separator.displayName
-
-const DropdownMenuShortcut = ({
-  className,
-  ...props
-}: React.HTMLAttributes<HTMLSpanElement>) => (
+));
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
+
+const DropdownMenuShortcut = ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>) => (
   <span
     className={cn("ml-auto text-xs tracking-widest text-muted-foreground", className)}
     {...props}
   />
-)
-DropdownMenuShortcut.displayName = "DropdownMenuShortcut"
+);
+DropdownMenuShortcut.displayName = "DropdownMenuShortcut";
 
 export {
   DropdownMenu,
-  DropdownMenuTrigger,
+  DropdownMenuCheckboxItem,
   DropdownMenuContent,
+  DropdownMenuGroup,
   DropdownMenuItem,
-  DropdownMenuCheckboxItem,
-  DropdownMenuRadioItem,
   DropdownMenuLabel,
+  DropdownMenuPortal,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
   DropdownMenuSeparator,
   DropdownMenuShortcut,
-  DropdownMenuGroup,
-  DropdownMenuPortal,
   DropdownMenuSub,
   DropdownMenuSubContent,
   DropdownMenuSubTrigger,
-  DropdownMenuRadioGroup,
-}
+  DropdownMenuTrigger,
+};
diff --git a/ui/src/components/ui/input.tsx b/ui/src/components/ui/input.tsx
index 89169058..73ea8679 100644
--- a/ui/src/components/ui/input.tsx
+++ b/ui/src/components/ui/input.tsx
@@ -1,6 +1,6 @@
-import * as React from "react"
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 function Input({ className, type, ...props }: React.ComponentProps<"input">) {
   return (
@@ -11,11 +11,11 @@ function Input({ className, type, ...props }: React.ComponentProps<"input">) {
         "file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground dark:bg-input/30 border-input h-9 w-full min-w-0 rounded-md border bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
         "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
         "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
-        className
+        className,
       )}
       {...props}
     />
-  )
+  );
 }
 
-export { Input }
+export { Input };
diff --git a/ui/src/components/ui/label.tsx b/ui/src/components/ui/label.tsx
index fb5fbc3e..aa7fe645 100644
--- a/ui/src/components/ui/label.tsx
+++ b/ui/src/components/ui/label.tsx
@@ -1,24 +1,21 @@
-"use client"
+"use client";
 
-import * as React from "react"
-import * as LabelPrimitive from "@radix-ui/react-label"
+import * as LabelPrimitive from "@radix-ui/react-label";
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
-function Label({
-  className,
-  ...props
-}: React.ComponentProps<typeof LabelPrimitive.Root>) {
+function Label({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>) {
   return (
     <LabelPrimitive.Root
       data-slot="label"
       className={cn(
         "flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
-        className
+        className,
       )}
       {...props}
     />
-  )
+  );
 }
 
-export { Label }
+export { Label };
diff --git a/ui/src/components/ui/resizable.tsx b/ui/src/components/ui/resizable.tsx
index fe0ebbde..f95e9d82 100644
--- a/ui/src/components/ui/resizable.tsx
+++ b/ui/src/components/ui/resizable.tsx
@@ -1,8 +1,8 @@
-import * as React from "react"
-import { GripVerticalIcon } from "lucide-react"
-import * as ResizablePrimitive from "react-resizable-panels"
+import { GripVerticalIcon } from "lucide-react";
+import type * as React from "react";
+import * as ResizablePrimitive from "react-resizable-panels";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 function ResizablePanelGroup({
   className,
@@ -11,19 +11,14 @@ function ResizablePanelGroup({
   return (
     <ResizablePrimitive.PanelGroup
       data-slot="resizable-panel-group"
-      className={cn(
-        "flex h-full w-full data-[panel-group-direction=vertical]:flex-col",
-        className
-      )}
+      className={cn("flex h-full w-full data-[panel-group-direction=vertical]:flex-col", className)}
       {...props}
     />
-  )
+  );
 }
 
-function ResizablePanel({
-  ...props
-}: React.ComponentProps<typeof ResizablePrimitive.Panel>) {
-  return <ResizablePrimitive.Panel data-slot="resizable-panel" {...props} />
+function ResizablePanel({ ...props }: React.ComponentProps<typeof ResizablePrimitive.Panel>) {
+  return <ResizablePrimitive.Panel data-slot="resizable-panel" {...props} />;
 }
 
 function ResizableHandle({
@@ -31,14 +26,14 @@ function ResizableHandle({
   className,
   ...props
 }: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
-  withHandle?: boolean
+  withHandle?: boolean;
 }) {
   return (
     <ResizablePrimitive.PanelResizeHandle
       data-slot="resizable-handle"
       className={cn(
         "bg-border focus-visible:ring-ring relative flex w-px items-center justify-center after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2 focus-visible:ring-1 focus-visible:ring-offset-1 focus-visible:outline-hidden data-[panel-group-direction=vertical]:h-px data-[panel-group-direction=vertical]:w-full data-[panel-group-direction=vertical]:after:left-0 data-[panel-group-direction=vertical]:after:h-1 data-[panel-group-direction=vertical]:after:w-full data-[panel-group-direction=vertical]:after:translate-x-0 data-[panel-group-direction=vertical]:after:-translate-y-1/2 [&[data-panel-group-direction=vertical]>div]:rotate-90",
-        className
+        className,
       )}
       {...props}
     >
@@ -48,7 +43,7 @@ function ResizableHandle({
         </div>
       )}
     </ResizablePrimitive.PanelResizeHandle>
-  )
+  );
 }
 
-export { ResizablePanelGroup, ResizablePanel, ResizableHandle }
+export { ResizableHandle, ResizablePanel, ResizablePanelGroup };
diff --git a/ui/src/components/ui/scroll-area.tsx b/ui/src/components/ui/scroll-area.tsx
index d59c53c2..9711a23a 100644
--- a/ui/src/components/ui/scroll-area.tsx
+++ b/ui/src/components/ui/scroll-area.tsx
@@ -1,7 +1,7 @@
-import * as React from "react"
-import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area"
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+import * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 const ScrollArea = React.forwardRef<
   React.ElementRef<typeof ScrollAreaPrimitive.Root>,
@@ -18,8 +18,8 @@ const ScrollArea = React.forwardRef<
     <ScrollBar />
     <ScrollAreaPrimitive.Corner />
   </ScrollAreaPrimitive.Root>
-))
-ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName
+));
+ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName;
 
 const ScrollBar = React.forwardRef<
   React.ElementRef<typeof ScrollAreaPrimitive.Scrollbar>,
@@ -30,17 +30,15 @@ const ScrollBar = React.forwardRef<
     orientation={orientation}
     className={cn(
       "flex touch-none select-none transition-colors",
-      orientation === "vertical" &&
-        "h-full w-2.5 border-l border-l-transparent p-[1px]",
-      orientation === "horizontal" &&
-        "h-2.5 flex-col border-t border-t-transparent p-[1px]",
-      className
+      orientation === "vertical" && "h-full w-2.5 border-l border-l-transparent p-[1px]",
+      orientation === "horizontal" && "h-2.5 flex-col border-t border-t-transparent p-[1px]",
+      className,
     )}
     {...props}
   >
     <ScrollAreaPrimitive.Thumb className="relative flex-1 rounded-full bg-border" />
   </ScrollAreaPrimitive.Scrollbar>
-))
-ScrollBar.displayName = ScrollAreaPrimitive.Scrollbar.displayName
+));
+ScrollBar.displayName = ScrollAreaPrimitive.Scrollbar.displayName;
 
-export { ScrollArea, ScrollBar }
+export { ScrollArea, ScrollBar };
diff --git a/ui/src/components/ui/select.tsx b/ui/src/components/ui/select.tsx
index d34798fa..c1843f5c 100644
--- a/ui/src/components/ui/select.tsx
+++ b/ui/src/components/ui/select.tsx
@@ -1,25 +1,19 @@
-import * as React from "react"
-import * as SelectPrimitive from "@radix-ui/react-select"
-import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react"
+import * as SelectPrimitive from "@radix-ui/react-select";
+import { CheckIcon, ChevronDownIcon, ChevronUpIcon } from "lucide-react";
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
-function Select({
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.Root>) {
-  return <SelectPrimitive.Root data-slot="select" {...props} />
+function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>) {
+  return <SelectPrimitive.Root data-slot="select" {...props} />;
 }
 
-function SelectGroup({
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.Group>) {
-  return <SelectPrimitive.Group data-slot="select-group" {...props} />
+function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>) {
+  return <SelectPrimitive.Group data-slot="select-group" {...props} />;
 }
 
-function SelectValue({
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.Value>) {
-  return <SelectPrimitive.Value data-slot="select-value" {...props} />
+function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>) {
+  return <SelectPrimitive.Value data-slot="select-value" {...props} />;
 }
 
 function SelectTrigger({
@@ -28,7 +22,7 @@ function SelectTrigger({
   children,
   ...props
 }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
-  size?: "sm" | "default"
+  size?: "sm" | "default";
 }) {
   return (
     <SelectPrimitive.Trigger
@@ -36,7 +30,7 @@ function SelectTrigger({
       data-size={size}
       className={cn(
         "border-input data-[placeholder]:text-muted-foreground [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 dark:hover:bg-input/50 flex w-fit items-center justify-between gap-2 rounded-md border bg-transparent px-3 py-2 text-sm whitespace-nowrap shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 data-[size=default]:h-9 data-[size=sm]:h-8 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-2 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
+        className,
       )}
       {...props}
     >
@@ -45,7 +39,7 @@ function SelectTrigger({
         <ChevronDownIcon className="size-4 opacity-50" />
       </SelectPrimitive.Icon>
     </SelectPrimitive.Trigger>
-  )
+  );
 }
 
 function SelectContent({
@@ -63,7 +57,7 @@ function SelectContent({
           "bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-(--radix-select-content-available-height) min-w-[8rem] origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border shadow-md",
           position === "popper" &&
             "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
-          className
+          className,
         )}
         position={position}
         align={align}
@@ -74,7 +68,7 @@ function SelectContent({
           className={cn(
             "p-1",
             position === "popper" &&
-              "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1"
+              "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)] scroll-my-1",
           )}
         >
           {children}
@@ -82,20 +76,17 @@ function SelectContent({
         <SelectScrollDownButton />
       </SelectPrimitive.Content>
     </SelectPrimitive.Portal>
-  )
+  );
 }
 
-function SelectLabel({
-  className,
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.Label>) {
+function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>) {
   return (
     <SelectPrimitive.Label
       data-slot="select-label"
       className={cn("text-muted-foreground px-2 py-1.5 text-xs", className)}
       {...props}
     />
-  )
+  );
 }
 
 function SelectItem({
@@ -108,7 +99,7 @@ function SelectItem({
       data-slot="select-item"
       className={cn(
         "focus:bg-accent focus:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex w-full cursor-default items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
-        className
+        className,
       )}
       {...props}
     >
@@ -119,7 +110,7 @@ function SelectItem({
       </span>
       <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
     </SelectPrimitive.Item>
-  )
+  );
 }
 
 function SelectSeparator({
@@ -132,7 +123,7 @@ function SelectSeparator({
       className={cn("bg-border pointer-events-none -mx-1 my-1 h-px", className)}
       {...props}
     />
-  )
+  );
 }
 
 function SelectScrollUpButton({
@@ -142,15 +133,12 @@ function SelectScrollUpButton({
   return (
     <SelectPrimitive.ScrollUpButton
       data-slot="select-scroll-up-button"
-      className={cn(
-        "flex cursor-default items-center justify-center py-1",
-        className
-      )}
+      className={cn("flex cursor-default items-center justify-center py-1", className)}
       {...props}
     >
       <ChevronUpIcon className="size-4" />
     </SelectPrimitive.ScrollUpButton>
-  )
+  );
 }
 
 function SelectScrollDownButton({
@@ -160,15 +148,12 @@ function SelectScrollDownButton({
   return (
     <SelectPrimitive.ScrollDownButton
       data-slot="select-scroll-down-button"
-      className={cn(
-        "flex cursor-default items-center justify-center py-1",
-        className
-      )}
+      className={cn("flex cursor-default items-center justify-center py-1", className)}
       {...props}
     >
       <ChevronDownIcon className="size-4" />
     </SelectPrimitive.ScrollDownButton>
-  )
+  );
 }
 
 export {
@@ -182,4 +167,4 @@ export {
   SelectSeparator,
   SelectTrigger,
   SelectValue,
-}
+};
diff --git a/ui/src/components/ui/separator.tsx b/ui/src/components/ui/separator.tsx
index bb3ad74c..434a10e8 100644
--- a/ui/src/components/ui/separator.tsx
+++ b/ui/src/components/ui/separator.tsx
@@ -1,7 +1,7 @@
-import * as React from "react"
-import * as SeparatorPrimitive from "@radix-ui/react-separator"
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 function Separator({
   className,
@@ -16,11 +16,11 @@ function Separator({
       orientation={orientation}
       className={cn(
         "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
-        className
+        className,
       )}
       {...props}
     />
-  )
+  );
 }
 
-export { Separator }
+export { Separator };
diff --git a/ui/src/components/ui/skeleton.tsx b/ui/src/components/ui/skeleton.tsx
index 32ea0ef7..01689981 100644
--- a/ui/src/components/ui/skeleton.tsx
+++ b/ui/src/components/ui/skeleton.tsx
@@ -1,4 +1,4 @@
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 function Skeleton({ className, ...props }: React.ComponentProps<"div">) {
   return (
@@ -7,7 +7,7 @@ function Skeleton({ className, ...props }: React.ComponentProps<"div">) {
       className={cn("bg-accent animate-pulse rounded-md", className)}
       {...props}
     />
-  )
+  );
 }
 
-export { Skeleton }
+export { Skeleton };
diff --git a/ui/src/components/ui/tabs.tsx b/ui/src/components/ui/tabs.tsx
index 7bf18aa7..fe38a4a6 100644
--- a/ui/src/components/ui/tabs.tsx
+++ b/ui/src/components/ui/tabs.tsx
@@ -1,8 +1,8 @@
-import * as React from "react"
-import { cva, type VariantProps } from "class-variance-authority"
-import { Tabs as TabsPrimitive } from "radix-ui"
+import { cva, type VariantProps } from "class-variance-authority";
+import { Tabs as TabsPrimitive } from "radix-ui";
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 function Tabs({
   className,
@@ -14,13 +14,10 @@ function Tabs({
       data-slot="tabs"
       data-orientation={orientation}
       orientation={orientation}
-      className={cn(
-        "group/tabs flex gap-2 data-[orientation=horizontal]:flex-col",
-        className
-      )}
+      className={cn("group/tabs flex gap-2 data-[orientation=horizontal]:flex-col", className)}
       {...props}
     />
-  )
+  );
 }
 
 const tabsListVariants = cva(
@@ -35,15 +32,14 @@ const tabsListVariants = cva(
     defaultVariants: {
       variant: "default",
     },
-  }
-)
+  },
+);
 
 function TabsList({
   className,
   variant = "default",
   ...props
-}: React.ComponentProps<typeof TabsPrimitive.List> &
-  VariantProps<typeof tabsListVariants>) {
+}: React.ComponentProps<typeof TabsPrimitive.List> & VariantProps<typeof tabsListVariants>) {
   return (
     <TabsPrimitive.List
       data-slot="tabs-list"
@@ -51,13 +47,10 @@ function TabsList({
       className={cn(tabsListVariants({ variant }), className)}
       {...props}
     />
-  )
+  );
 }
 
-function TabsTrigger({
-  className,
-  ...props
-}: React.ComponentProps<typeof TabsPrimitive.Trigger>) {
+function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>) {
   return (
     <TabsPrimitive.Trigger
       data-slot="tabs-trigger"
@@ -66,24 +59,21 @@ function TabsTrigger({
         "group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-[state=active]:bg-transparent dark:group-data-[variant=line]/tabs-list:data-[state=active]:border-transparent dark:group-data-[variant=line]/tabs-list:data-[state=active]:bg-transparent",
         "data-[state=active]:bg-background dark:data-[state=active]:text-foreground dark:data-[state=active]:border-input dark:data-[state=active]:bg-input/30 data-[state=active]:text-foreground",
         "after:bg-foreground after:absolute after:opacity-0 after:transition-opacity group-data-[orientation=horizontal]/tabs:after:inset-x-0 group-data-[orientation=horizontal]/tabs:after:bottom-[-5px] group-data-[orientation=horizontal]/tabs:after:h-0.5 group-data-[orientation=vertical]/tabs:after:inset-y-0 group-data-[orientation=vertical]/tabs:after:-right-1 group-data-[orientation=vertical]/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-[state=active]:after:opacity-100",
-        className
+        className,
       )}
       {...props}
     />
-  )
+  );
 }
 
-function TabsContent({
-  className,
-  ...props
-}: React.ComponentProps<typeof TabsPrimitive.Content>) {
+function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>) {
   return (
     <TabsPrimitive.Content
       data-slot="tabs-content"
       className={cn("flex-1 outline-none", className)}
       {...props}
     />
-  )
+  );
 }
 
-export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants }
+export { Tabs, TabsContent, TabsList, TabsTrigger, tabsListVariants };
diff --git a/ui/src/components/ui/textarea.tsx b/ui/src/components/ui/textarea.tsx
index 7f21b5e7..4f6221ba 100644
--- a/ui/src/components/ui/textarea.tsx
+++ b/ui/src/components/ui/textarea.tsx
@@ -1,6 +1,6 @@
-import * as React from "react"
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
   return (
@@ -8,11 +8,11 @@ function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
       data-slot="textarea"
       className={cn(
         "border-input placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 flex field-sizing-content min-h-16 w-full rounded-md border bg-transparent px-3 py-2 text-base shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
-        className
+        className,
       )}
       {...props}
     />
-  )
+  );
 }
 
-export { Textarea }
+export { Textarea };
diff --git a/ui/src/components/ui/tooltip.tsx b/ui/src/components/ui/tooltip.tsx
index a4e90d4e..216b5ce3 100644
--- a/ui/src/components/ui/tooltip.tsx
+++ b/ui/src/components/ui/tooltip.tsx
@@ -1,9 +1,9 @@
-"use client"
+"use client";
 
-import * as React from "react"
-import * as TooltipPrimitive from "@radix-ui/react-tooltip"
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import type * as React from "react";
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/lib/utils";
 
 function TooltipProvider({
   delayDuration = 0,
@@ -15,23 +15,19 @@ function TooltipProvider({
       delayDuration={delayDuration}
       {...props}
     />
-  )
+  );
 }
 
-function Tooltip({
-  ...props
-}: React.ComponentProps<typeof TooltipPrimitive.Root>) {
+function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>) {
   return (
     <TooltipProvider>
       <TooltipPrimitive.Root data-slot="tooltip" {...props} />
     </TooltipProvider>
-  )
+  );
 }
 
-function TooltipTrigger({
-  ...props
-}: React.ComponentProps<typeof TooltipPrimitive.Trigger>) {
-  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />
+function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>) {
+  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />;
 }
 
 function TooltipContent({
@@ -47,7 +43,7 @@ function TooltipContent({
         sideOffset={sideOffset}
         className={cn(
           "bg-foreground text-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit origin-(--radix-tooltip-content-transform-origin) rounded-md px-3 py-1.5 text-xs text-balance",
-          className
+          className,
         )}
         {...props}
       >
@@ -55,7 +51,7 @@ function TooltipContent({
         <TooltipPrimitive.Arrow className="bg-foreground fill-foreground z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px]" />
       </TooltipPrimitive.Content>
     </TooltipPrimitive.Portal>
-  )
+  );
 }
 
-export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };
diff --git a/ui/src/components/ui/tree.tsx b/ui/src/components/ui/tree.tsx
index 1daf1aae..44694c13 100644
--- a/ui/src/components/ui/tree.tsx
+++ b/ui/src/components/ui/tree.tsx
@@ -4,9 +4,9 @@
  * No semantic meaning imposed - purely structural hierarchy
  */
 
+import { ChevronRight, File, Folder, FolderOpen } from "lucide-react";
 import * as React from "react";
 import { cn } from "@/lib/utils";
-import { ChevronRight, Folder, FolderOpen, File } from "lucide-react";
 
 interface TreeNodeProps {
   id: string;
@@ -15,7 +15,7 @@ interface TreeNodeProps {
   kind: "file" | "folder";
   children?: TreeNodeProps[];
   icon?: React.ReactNode;
-  metadata?: Record<string, any>;
+  metadata?: Record<string, unknown>;
 }
 
 interface TreeProps {
@@ -37,23 +37,22 @@ interface TreeItemProps {
   renderNode?: (node: TreeNodeProps, defaultRender: React.ReactNode) => React.ReactNode;
 }
 
+interface TreeItemRendererProps {
+  node: TreeNodeProps;
+  level: number;
+  expandedIds?: Map<string, boolean>;
+  onToggle: (id: string) => void;
+  onSelect?: (node: TreeNodeProps) => void;
+  onContextMenu?: (node: TreeNodeProps, event: React.MouseEvent) => void;
+  renderNode?: (node: TreeNodeProps, defaultRender: React.ReactNode) => React.ReactNode;
+}
+
 /**
  * TreeItem - Individual tree node renderer
  * Follows VS Code explorer styling and interactions
  */
-const TreeItem = React.forwardRef<HTMLDivElement, TreeItemProps>(
-  (
-    {
-      node,
-      level,
-      isExpanded,
-      onToggle,
-      onSelect,
-      onContextMenu,
-      renderNode,
-    },
-    ref
-  ) => {
+const TreeItem = React.forwardRef<HTMLButtonElement, TreeItemProps>(
+  ({ node, level, isExpanded, onToggle, onSelect, onContextMenu, renderNode }, ref) => {
     const hasChildren = node.children && node.children.length > 0;
     const isFolder = node.kind === "folder";
 
@@ -75,9 +74,10 @@ const TreeItem = React.forwardRef<HTMLDivElement, TreeItemProps>(
     };
 
     const DefaultRender = (
-      <div
+      <button
+        type="button"
         ref={ref}
-        className="group flex items-center min-h-[28px] px-2 py-1 rounded-sm cursor-pointer select-none hover:bg-accent/50 transition-colors"
+        className="group flex items-center min-h-[28px] w-full px-2 py-1 rounded-sm cursor-pointer select-none hover:bg-accent/50 transition-colors text-left"
         style={{ paddingLeft: `${level * 12 + 4}px` }}
         onClick={handleSelect}
         onContextMenu={handleContextMenu}
@@ -87,20 +87,18 @@ const TreeItem = React.forwardRef<HTMLDivElement, TreeItemProps>(
         {/* Expand/collapse toggle */}
         {isFolder && (
           <button
+            type="button"
             className={cn(
               "flex items-center justify-center w-5 h-5 mr-1 flex-shrink-0",
               "text-muted-foreground hover:text-foreground transition-colors",
-              hasChildren ? "cursor-pointer" : "cursor-default opacity-0"
+              hasChildren ? "cursor-pointer" : "cursor-default opacity-0",
             )}
             onClick={handleToggle}
             aria-label={isExpanded ? "Collapse" : "Expand"}
             disabled={!hasChildren}
           >
             <ChevronRight
-              className={cn(
-                "h-4 w-4 transition-transform",
-                isExpanded && "rotate-90"
-              )}
+              className={cn("h-4 w-4 transition-transform", isExpanded && "rotate-90")}
             />
           </button>
         )}
@@ -121,10 +119,8 @@ const TreeItem = React.forwardRef<HTMLDivElement, TreeItemProps>(
         </div>
 
         {/* Node label */}
-        <span className="truncate text-sm text-foreground flex-1">
-          {node.name}
-        </span>
-      </div>
+        <span className="truncate text-sm text-foreground flex-1">{node.name}</span>
+      </button>
     );
 
     return (
@@ -132,7 +128,7 @@ const TreeItem = React.forwardRef<HTMLDivElement, TreeItemProps>(
         {renderNode ? renderNode(node, DefaultRender) : DefaultRender}
         {isFolder && isExpanded && hasChildren && (
           <div className="flex flex-col">
-            {node.children!.map(child => (
+            {node.children?.map((child) => (
               <TreeItemRenderer
                 key={child.id}
                 node={child}
@@ -155,7 +151,7 @@ const TreeItem = React.forwardRef<HTMLDivElement, TreeItemProps>(
         )}
       </div>
     );
-  }
+  },
 );
 TreeItem.displayName = "TreeItem";
 
@@ -163,19 +159,14 @@ TreeItem.displayName = "TreeItem";
  * TreeItemRenderer - Manages expanded state for tree items
  */
 const TreeItemRenderer = React.memo(
-  ({
-    node,
-    level,
-    expandedIds,
-    ...props
-  }: TreeItemProps & { expandedIds?: Map<string, boolean> }) => {
+  ({ node, level, expandedIds, onToggle, ...props }: TreeItemRendererProps) => {
     const [expandedState, setExpandedState] = React.useState(
-      expandedIds?.get(node.id) ?? level < 2
+      expandedIds?.get(node.id) ?? level < 2,
     );
 
     const handleToggle = (id: string) => {
       setExpandedState(!expandedState);
-      props.onToggle(id);
+      onToggle(id);
     };
 
     return (
@@ -187,7 +178,7 @@ const TreeItemRenderer = React.memo(
         {...props}
       />
     );
-  }
+  },
 );
 TreeItemRenderer.displayName = "TreeItemRenderer";
 
@@ -196,27 +187,19 @@ TreeItemRenderer.displayName = "TreeItemRenderer";
  * Manages expansion state globally
  */
 const Tree = React.forwardRef<HTMLDivElement, TreeProps>(
-  (
-    {
-      nodes,
-      onSelect,
-      onContextMenu,
-      defaultExpandedIds,
-      className,
-      renderNode,
-    },
-    ref
-  ) => {
-    const [expandedIds, setExpandedIds] = React.useState<Map<string, boolean>>(
-      () => {
-        const map = new Map<string, boolean>();
-        defaultExpandedIds?.forEach(id => map.set(id, true));
-        return map;
+  ({ nodes, onSelect, onContextMenu, defaultExpandedIds, className, renderNode }, ref) => {
+    const [expandedIds, setExpandedIds] = React.useState<Map<string, boolean>>(() => {
+      const map = new Map<string, boolean>();
+      if (defaultExpandedIds) {
+        for (const id of defaultExpandedIds) {
+          map.set(id, true);
+        }
       }
-    );
+      return map;
+    });
 
     const handleToggle = React.useCallback((id: string) => {
-      setExpandedIds(prev => {
+      setExpandedIds((prev) => {
         const next = new Map(prev);
         next.set(id, !next.get(id));
         return next;
@@ -233,13 +216,12 @@ const Tree = React.forwardRef<HTMLDivElement, TreeProps>(
 
     return (
       <div ref={ref} className={cn("flex flex-col", className)}>
-        {nodes.map(node => (
+        {nodes.map((node) => (
           <TreeItemRenderer
             key={node.id}
             node={node}
             level={0}
             expandedIds={expandedIds}
-            isExpanded={expandedIds.get(node.id) ?? false}
             onToggle={handleToggle}
             onSelect={onSelect}
             onContextMenu={onContextMenu}
@@ -248,7 +230,7 @@ const Tree = React.forwardRef<HTMLDivElement, TreeProps>(
         ))}
       </div>
     );
-  }
+  },
 );
 Tree.displayName = "Tree";
 
diff --git a/ui/src/env.d.ts b/ui/src/env.d.ts
index 2cf5534b..c4133b2a 100644
--- a/ui/src/env.d.ts
+++ b/ui/src/env.d.ts
@@ -4,8 +4,8 @@
  * Imports the SVG file as a React component.
  * @requires [@rsbuild/plugin-svgr](https://npmjs.com/package/@rsbuild/plugin-svgr)
  */
-declare module '*.svg?react' {
-  import type React from 'react';
+declare module "*.svg?react" {
+  import type React from "react";
   const ReactComponent: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
   export default ReactComponent;
 }
diff --git a/ui/src/lib/file-preview-plugins.ts b/ui/src/lib/file-preview-plugins.ts
index f0e8ee56..fe3915d2 100644
--- a/ui/src/lib/file-preview-plugins.ts
+++ b/ui/src/lib/file-preview-plugins.ts
@@ -1,201 +1,54 @@
-/**
- * File Preview Plugin Framework
- * 
- * This module provides a plugin-based architecture for rendering file previews.
- * Different file types can have custom preview renderers by registering plugins.
- * 
- * ## Usage
- * 
- * 1. Create a plugin implementing `FilePreviewPlugin`:
- * ```typescript
- * const myPlugin: FilePreviewPlugin = {
- *   id: 'my-plugin',
- *   name: 'My Plugin',
- *   extensions: ['.xyz'],
- *   Component: MyPreviewComponent,
- * };
- * ```
- * 
- * 2. Register the plugin:
- * ```typescript
- * import { filePreviewPluginRegistry } from '@/lib/file-preview-plugins';
- * filePreviewPluginRegistry.register(myPlugin);
- * ```
- * 
- * 3. Use in FilePreview component:
- * ```typescript
- * const plugin = filePreviewPluginRegistry.getPluginForFile(filename);
- * if (plugin) {
- *   return <plugin.Component content={content} name={name} path={path} />;
- * }
- * ```
- */
+import {
+  listFilePreviewContributions,
+  registerFilePreviewContribution,
+  unregisterFilePreviewContribution,
+} from "@/plugins/contribution-runtime";
+import type { FilePreviewPlugin } from "@/plugins/types";
 
-import React from 'react';
+export type { FilePreviewContentProps, FilePreviewPlugin } from "@/plugins/types";
 
-// ============================================================================
-// Types & Interfaces
-// ============================================================================
-
-/**
- * Props passed to file preview plugin components.
- */
-export interface FilePreviewContentProps {
-    /** The content of the file as a string */
-    content: string;
-    /** The filename (e.g., "README.md") */
-    name: string;
-    /** The full path to the file */
-    path: string;
-    /** The folder ID for API operations (e.g., "workspace" or a UUID) */
-    folderId: string;
-}
-
-/**
- * Definition of a file preview plugin.
- * 
- * Plugins are matched by file extension with optional priority ordering.
- * When multiple plugins match the same extension, the one with higher priority wins.
- */
-export interface FilePreviewPlugin {
-    /** Unique identifier for the plugin */
-    id: string;
-
-    /** Display name for the plugin */
-    name: string;
-
-    /** 
-     * File extensions this plugin handles (including the dot).
-     * Example: ['.md', '.markdown']
-     */
-    extensions: string[];
-
-    /**
-     * Priority for plugin resolution when multiple plugins match.
-     * Higher values take precedence. Default is 0.
-     */
-    priority?: number;
-
-    /**
-     * Optional custom matching function for more complex logic.
-     * If provided and returns true, this plugin will be used.
-     * Extension matching is still checked first.
-     */
-    canHandle?: (props: { name: string; path: string }) => boolean;
-
-    /**
-     * The React component that renders the file preview.
-     */
-    Component: React.ComponentType<FilePreviewContentProps>;
-}
-
-// ============================================================================
-// Plugin Registry
-// ============================================================================
-
-/**
- * Registry for file preview plugins.
- * Provides methods to register plugins and resolve the best plugin for a file.
- */
 class FilePreviewPluginRegistry {
-    private plugins: FilePreviewPlugin[] = [];
+  register(plugin: FilePreviewPlugin): void {
+    registerFilePreviewContribution(plugin);
+  }
 
-    /**
-     * Register a new file preview plugin.
-     * 
-     * @param plugin - The plugin to register
-     * @throws Error if a plugin with the same ID is already registered
-     */
-    register(plugin: FilePreviewPlugin): void {
-        // Check for duplicate IDs
-        if (this.plugins.some(p => p.id === plugin.id)) {
-            console.warn(
-                `[FilePreviewPluginRegistry] Plugin with id "${plugin.id}" is already registered. Skipping.`
-            );
-            return;
-        }
+  unregister(pluginId: string): boolean {
+    return unregisterFilePreviewContribution(pluginId);
+  }
 
-        this.plugins.push(plugin);
+  getPluginForFile(filename: string, path?: string): FilePreviewPlugin | null {
+    const extension = this.getExtension(filename);
 
-        // Keep plugins sorted by priority (highest first) for efficient lookup
-        this.plugins.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
-    }
+    for (const plugin of listFilePreviewContributions()) {
+      if (plugin.extensions.includes(extension)) {
+        return plugin;
+      }
 
-    /**
-     * Unregister a plugin by its ID.
-     * 
-     * @param pluginId - The ID of the plugin to remove
-     * @returns true if a plugin was removed, false otherwise
-     */
-    unregister(pluginId: string): boolean {
-        const initialLength = this.plugins.length;
-        this.plugins = this.plugins.filter(p => p.id !== pluginId);
-        return this.plugins.length < initialLength;
+      if (plugin.canHandle?.({ name: filename, path: path ?? filename })) {
+        return plugin;
+      }
     }
 
-    /**
-     * Get the best matching plugin for a given filename.
-     * 
-     * Resolution order:
-     * 1. Plugins are checked in priority order (highest first)
-     * 2. For each plugin, extension matching is checked first
-     * 3. If no extension match, canHandle() is called if provided
-     * 4. First matching plugin wins
-     * 
-     * @param filename - The name of the file (e.g., "README.md")
-     * @param path - Optional full path for canHandle matching
-     * @returns The matching plugin or null if none found
-     */
-    getPluginForFile(filename: string, path?: string): FilePreviewPlugin | null {
-        const extension = this.getExtension(filename);
-
-        for (const plugin of this.plugins) {
-            // Check extension match
-            if (plugin.extensions.includes(extension)) {
-                return plugin;
-            }
+    return null;
+  }
 
-            // Check custom canHandle if provided
-            if (plugin.canHandle?.({ name: filename, path: path ?? filename })) {
-                return plugin;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Get all registered plugins.
-     * 
-     * @returns Array of all registered plugins (sorted by priority)
-     */
-    getAllPlugins(): FilePreviewPlugin[] {
-        return [...this.plugins];
-    }
+  getAllPlugins(): FilePreviewPlugin[] {
+    return listFilePreviewContributions();
+  }
 
-    /**
-     * Clear all registered plugins.
-     * Useful for testing or plugin reloading.
-     */
-    clear(): void {
-        this.plugins = [];
+  clear(): void {
+    for (const plugin of listFilePreviewContributions()) {
+      unregisterFilePreviewContribution(plugin.id);
     }
+  }
 
-    /**
-     * Extract the file extension from a filename.
-     * Returns lowercase extension with dot (e.g., ".md").
-     */
-    private getExtension(filename: string): string {
-        const lastDot = filename.lastIndexOf('.');
-        if (lastDot === -1 || lastDot === 0) {
-            return '';
-        }
-        return filename.slice(lastDot).toLowerCase();
+  private getExtension(filename: string): string {
+    const lastDot = filename.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === 0) {
+      return "";
     }
+    return filename.slice(lastDot).toLowerCase();
+  }
 }
 
-/**
- * Singleton instance of the file preview plugin registry.
- * Import and use this to register or resolve plugins.
- */
 export const filePreviewPluginRegistry = new FilePreviewPluginRegistry();
diff --git a/ui/src/lib/plugins/markdown-plugin.ts b/ui/src/lib/plugins/markdown-plugin.ts
index 845e37d4..50b3d4c7 100644
--- a/ui/src/lib/plugins/markdown-plugin.ts
+++ b/ui/src/lib/plugins/markdown-plugin.ts
@@ -1,29 +1,29 @@
 /**
  * Markdown Preview Plugin
- * 
+ *
  * Registers a file preview plugin for markdown files (.md, .markdown, .mdx).
  * Uses the MarkdownPreview component for rendering.
  */
 
-import { filePreviewPluginRegistry, type FilePreviewPlugin } from '@/lib/file-preview-plugins';
-import { MarkdownPreview } from '@/components/previews/MarkdownPreview';
+import { MarkdownPreview } from "@/components/previews/MarkdownPreview";
+import { type FilePreviewPlugin, filePreviewPluginRegistry } from "@/lib/file-preview-plugins";
 
 /**
  * Markdown file preview plugin definition.
  */
 export const markdownPlugin: FilePreviewPlugin = {
-    id: 'markdown',
-    name: 'Markdown Preview',
-    extensions: ['.md', '.markdown', '.mdx'],
-    priority: 10, // Higher priority than default
-    Component: MarkdownPreview,
+  id: "markdown",
+  name: "Markdown Preview",
+  extensions: [".md", ".markdown", ".mdx"],
+  priority: 10, // Higher priority than default
+  Component: MarkdownPreview,
 };
 
 /**
  * Register the markdown plugin with the central registry.
  */
 export function registerMarkdownPlugin(): void {
-    filePreviewPluginRegistry.register(markdownPlugin);
+  filePreviewPluginRegistry.register(markdownPlugin);
 }
 
 // Auto-register when this module is imported
diff --git a/ui/src/lib/plugins/workflow-plugin.ts b/ui/src/lib/plugins/workflow-plugin.ts
index ec10d84f..9f226359 100644
--- a/ui/src/lib/plugins/workflow-plugin.ts
+++ b/ui/src/lib/plugins/workflow-plugin.ts
@@ -1,29 +1,29 @@
 /**
  * Workflow Preview Plugin
- * 
+ *
  * Registers a file preview plugin for workflow files (.flow).
  * Uses the WorkflowPreview component for rendering the workflow graph.
  */
 
-import { filePreviewPluginRegistry, type FilePreviewPlugin } from '@/lib/file-preview-plugins';
-import { WorkflowPreview } from '@/components/previews/WorkflowPreview';
+import { WorkflowPreview } from "@/components/previews/WorkflowPreview";
+import { type FilePreviewPlugin, filePreviewPluginRegistry } from "@/lib/file-preview-plugins";
 
 /**
  * Workflow file preview plugin definition.
  */
 export const workflowPlugin: FilePreviewPlugin = {
-    id: 'workflow',
-    name: 'Workflow Preview',
-    extensions: ['.flow'],
-    priority: 10, // Higher priority than default
-    Component: WorkflowPreview,
+  id: "workflow",
+  name: "Workflow Preview",
+  extensions: [".flow"],
+  priority: 10, // Higher priority than default
+  Component: WorkflowPreview,
 };
 
 /**
  * Register the workflow plugin with the central registry.
  */
 export function registerWorkflowPlugin(): void {
-    filePreviewPluginRegistry.register(workflowPlugin);
+  filePreviewPluginRegistry.register(workflowPlugin);
 }
 
 // Auto-register when this module is imported
diff --git a/ui/src/lib/utils.ts b/ui/src/lib/utils.ts
index 21c2d465..365058ce 100644
--- a/ui/src/lib/utils.ts
+++ b/ui/src/lib/utils.ts
@@ -1,6 +1,6 @@
-import { clsx, type ClassValue } from "clsx"
-import { twMerge } from "tailwind-merge"
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
 
 export function cn(...inputs: ClassValue[]) {
-    return twMerge(clsx(inputs))
-}
\ No newline at end of file
+  return twMerge(clsx(inputs));
+}
diff --git a/ui/src/lib/workflow-utils.ts b/ui/src/lib/workflow-utils.ts
index 00337147..6e5bd9bc 100644
--- a/ui/src/lib/workflow-utils.ts
+++ b/ui/src/lib/workflow-utils.ts
@@ -1,179 +1,195 @@
-import { type Node, type Edge } from '@xyflow/react';
-import type { TaskNodeJson, EdgeJson, TaskGraphJson } from '@/types/task_graph_ir';
+import type { Edge, Node } from "@xyflow/react";
+import type { EdgeJson, TaskGraphJson, TaskNodeJson } from "@/types/task_graph_ir";
 
 /**
  * Converts TaskGraph JSON IR to React Flow elements with auto-layout.
  * Uses a simple layer-based layout algorithm (Top-Down).
  */
 export const getLayoutedElements = (nodes: TaskNodeJson[], edges: EdgeJson[]) => {
-    // Convert TaskNodeJson to generic format for layout
-    const genericNodes = nodes.map(n => ({ id: n.id, type: n.type }));
-    const genericEdges = edges.map(e => ({ from: e.from, to: e.to }));
-
-    const layout = calculateLayout(genericNodes, genericEdges);
-
-    // Map back to React Flow elements
-    const flowNodes: Node[] = nodes.map(node => {
-        const pos = layout[node.id] || { x: 0, y: 0 };
-
-        // Map type to React Flow type
-        let type = 'process';
-        const lowerType = node.type.toLowerCase();
-        if (lowerType.includes('start') || lowerType.includes('load')) type = 'start';
-        else if (lowerType.includes('end') || lowerType.includes('save')) type = 'end';
-
-        return {
-            id: node.id,
-            type,
-            position: pos,
-            data: {
-                label: node.label || node.type,
-                ...node.params
-            },
-        };
-    });
+  // Convert TaskNodeJson to generic format for layout
+  const genericNodes = nodes.map((n) => ({ id: n.id, type: n.type }));
+  const genericEdges = edges.map((e) => ({ from: e.from, to: e.to }));
+
+  const layout = calculateLayout(genericNodes, genericEdges);
+
+  // Map back to React Flow elements
+  const flowNodes: Node[] = nodes.map((node) => {
+    const pos = layout[node.id] || { x: 0, y: 0 };
+
+    // Map type to React Flow type
+    let type = "process";
+    const lowerType = node.type.toLowerCase();
+    if (lowerType.includes("start") || lowerType.includes("load")) type = "start";
+    else if (lowerType.includes("end") || lowerType.includes("save")) type = "end";
+
+    return {
+      id: node.id,
+      type,
+      position: pos,
+      data: {
+        label: node.label || node.type,
+        ...node.params,
+      },
+    };
+  });
 
-    const flowEdges: Edge[] = edges.map(edge => ({
-        id: `e_${edge.from}_${edge.to}`,
-        source: edge.from,
-        target: edge.to,
-        animated: true,
-        type: 'smoothstep',
-    }));
+  const flowEdges: Edge[] = edges.map((edge) => ({
+    id: `e_${edge.from}_${edge.to}`,
+    source: edge.from,
+    target: edge.to,
+    animated: true,
+    type: "smoothstep",
+  }));
 
-    return { nodes: flowNodes, edges: flowEdges };
+  return { nodes: flowNodes, edges: flowEdges };
 };
 
 /**
  * Auto-layouts existing React Flow nodes and edges.
  */
 export const autoLayoutNodes = (nodes: Node[], edges: Edge[]) => {
-    const genericNodes = nodes.map(n => ({ id: n.id, type: n.type || 'process' }));
-    const genericEdges = edges.map(e => ({ from: e.source, to: e.target }));
+  const genericNodes = nodes.map((n) => ({ id: n.id, type: n.type || "process" }));
+  const genericEdges = edges.map((e) => ({ from: e.source, to: e.target }));
 
-    const layout = calculateLayout(genericNodes, genericEdges);
+  const layout = calculateLayout(genericNodes, genericEdges);
 
-    const layoutedNodes = nodes.map(node => ({
-        ...node,
-        position: layout[node.id] || node.position
-    }));
+  const layoutedNodes = nodes.map((node) => ({
+    ...node,
+    position: layout[node.id] || node.position,
+  }));
 
-    return { nodes: layoutedNodes, edges };
+  return { nodes: layoutedNodes, edges };
 };
 
 // Shared layout logic
-const calculateLayout = (nodes: { id: string }[], edges: { from: string, to: string }[]) => {
-    const rankSep = 250; // Increased from 150
-    const nodeSep = 300; // Increased from 200
-
-    const adj: Record<string, string[]> = {};
-    const inDegree: Record<string, number> = {};
-
-    nodes.forEach(n => {
-        adj[n.id] = [];
-        inDegree[n.id] = 0;
-    });
-
-    edges.forEach(e => {
-        if (adj[e.from]) adj[e.from].push(e.to);
-        inDegree[e.to] = (inDegree[e.to] || 0) + 1;
-    });
-
-    const levels: Record<string, number> = {};
-    const queue: string[] = nodes.filter(n => inDegree[n.id] === 0).map(n => n.id);
-
-    queue.forEach(id => { levels[id] = 0; });
-
-    const tempInDegree = { ...inDegree };
-    const processQueue = [...queue];
-
-    while (processQueue.length > 0) {
-        const u = processQueue.shift()!;
-        if (adj[u]) {
-            adj[u].forEach(v => {
-                levels[v] = Math.max(levels[v] || 0, (levels[u] || 0) + 1);
-                tempInDegree[v]--;
-                if (tempInDegree[v] === 0) {
-                    processQueue.push(v);
-                }
-            });
+const calculateLayout = (nodes: { id: string }[], edges: { from: string; to: string }[]) => {
+  const rankSep = 250; // Increased from 150
+  const nodeSep = 300; // Increased from 200
+
+  const adj: Record<string, string[]> = {};
+  const inDegree: Record<string, number> = {};
+
+  nodes.forEach((n) => {
+    adj[n.id] = [];
+    inDegree[n.id] = 0;
+  });
+
+  edges.forEach((e) => {
+    if (adj[e.from]) adj[e.from].push(e.to);
+    inDegree[e.to] = (inDegree[e.to] || 0) + 1;
+  });
+
+  const levels: Record<string, number> = {};
+  const queue: string[] = nodes.filter((n) => inDegree[n.id] === 0).map((n) => n.id);
+
+  queue.forEach((id) => {
+    levels[id] = 0;
+  });
+
+  const tempInDegree = { ...inDegree };
+  const processQueue = [...queue];
+
+  while (processQueue.length > 0) {
+    const u = processQueue.shift();
+    if (u === undefined) break;
+    if (adj[u]) {
+      adj[u].forEach((v) => {
+        levels[v] = Math.max(levels[v] || 0, (levels[u] || 0) + 1);
+        tempInDegree[v]--;
+        if (tempInDegree[v] === 0) {
+          processQueue.push(v);
         }
+      });
     }
+  }
 
-    // Handle disconnected/cycles
-    nodes.forEach(n => {
-        if (levels[n.id] === undefined) levels[n.id] = 0;
-    });
+  // Handle disconnected/cycles
+  nodes.forEach((n) => {
+    if (levels[n.id] === undefined) levels[n.id] = 0;
+  });
 
-    const levelGroups: Record<number, string[]> = {};
-    let maxLevel = 0;
-    Object.entries(levels).forEach(([id, level]) => {
-        if (!levelGroups[level]) levelGroups[level] = [];
-        levelGroups[level].push(id);
-        maxLevel = Math.max(maxLevel, level);
-    });
+  const levelGroups: Record<number, string[]> = {};
+  let maxLevel = 0;
+  Object.entries(levels).forEach(([id, level]) => {
+    if (!levelGroups[level]) levelGroups[level] = [];
+    levelGroups[level].push(id);
+    maxLevel = Math.max(maxLevel, level);
+  });
 
-    const maxNodesInLevel = Math.max(...Object.values(levelGroups).map(g => g.length));
-    const totalWidth = maxNodesInLevel * nodeSep;
+  const maxNodesInLevel = Math.max(...Object.values(levelGroups).map((g) => g.length));
+  const totalWidth = maxNodesInLevel * nodeSep;
 
-    const layout: Record<string, { x: number, y: number }> = {};
+  const layout: Record<string, { x: number; y: number }> = {};
 
-    nodes.forEach(node => {
-        const level = levels[node.id];
-        const indexInLevel = levelGroups[level].indexOf(node.id);
-        const nodesInThisLevel = levelGroups[level].length;
+  nodes.forEach((node) => {
+    const level = levels[node.id];
+    const indexInLevel = levelGroups[level].indexOf(node.id);
+    const nodesInThisLevel = levelGroups[level].length;
 
-        const levelWidth = nodesInThisLevel * nodeSep;
-        const xOffset = (totalWidth - levelWidth) / 2;
+    const levelWidth = nodesInThisLevel * nodeSep;
+    const xOffset = (totalWidth - levelWidth) / 2;
 
-        const x = xOffset + indexInLevel * nodeSep + 50;
-        const y = level * rankSep + 50;
+    const x = xOffset + indexInLevel * nodeSep + 50;
+    const y = level * rankSep + 50;
 
-        layout[node.id] = { x, y };
-    });
+    layout[node.id] = { x, y };
+  });
 
-    return layout;
+  return layout;
 };
 
 /**
  * Converts React Flow nodes and edges to TaskGraph JSON IR.
  */
-export const toTaskGraphJson = (nodes: Node[], edges: Edge[], name: string = "Workflow"): TaskGraphJson => {
-    const taskNodes: TaskNodeJson[] = nodes.map(node => {
-        // Extract config from node data (static configuration)
-        const { config, label, category, isOutput, status, plannedColor, ...otherData } = node.data;
-
-        return {
-            id: node.id,
-            type: node.type === 'process' ? (category ? `${category}.${label}` : label as string) : node.type || 'process',
-            label: label as string,
-            config: config || {}, // Static configuration for the node
-            params: otherData, // Other runtime parameters (if any)
-            metadata: {
-                position: node.position,
-                isOutput,
-                ...otherData
-            }
-        };
-    });
-
-    const taskEdges: EdgeJson[] = edges.map(edge => ({
-        from: edge.source,
-        to: edge.target,
-        kind: 'dependency'
-    }));
-
-    const targets = nodes.filter(n => n.data.isOutput).map(n => n.id);
+export const toTaskGraphJson = (
+  nodes: Node[],
+  edges: Edge[],
+  name: string = "Workflow",
+): TaskGraphJson => {
+  const taskNodes: TaskNodeJson[] = nodes.map((node) => {
+    // Extract config from node data (static configuration)
+    const { config, label, category, isOutput, status, plannedColor, ...otherData } = node.data;
+    const configRecord =
+      typeof config === "object" && config !== null && !Array.isArray(config)
+        ? (config as Record<string, unknown>)
+        : ({} as Record<string, unknown>);
 
     return {
-        name,
-        nodes: taskNodes,
-        edges: taskEdges,
-        targets: targets.length > 0 ? targets : undefined,
-        metadata: {
-            createdAt: new Date().toISOString()
-        }
+      id: node.id,
+      type:
+        node.type === "process"
+          ? category
+            ? `${category}.${label}`
+            : (label as string)
+          : node.type || "process",
+      label: label as string,
+      config: configRecord, // Static configuration for the node
+      params: otherData, // Other runtime parameters (if any)
+      metadata: {
+        position: node.position,
+        isOutput,
+        ...otherData,
+      },
     };
+  });
+
+  const taskEdges: EdgeJson[] = edges.map((edge) => ({
+    from: edge.source,
+    to: edge.target,
+    kind: "dependency",
+  }));
+
+  const targets = nodes.filter((n) => n.data.isOutput).map((n) => n.id);
+
+  return {
+    name,
+    nodes: taskNodes,
+    edges: taskEdges,
+    targets: targets.length > 0 ? targets : undefined,
+    metadata: {
+      createdAt: new Date().toISOString(),
+    },
+  };
 };
 
 /**
@@ -181,104 +197,117 @@ export const toTaskGraphJson = (nodes: Node[], edges: Edge[], name: string = "Wo
  * Returns a topologically sorted list of node IDs.
  */
 export const planExecution = (nodes: Node[], edges: Edge[], targets: string[]): string[] => {
-    // 1. Build dependency graph (reverse adjacency list)
-    // node -> [dependencies]
-    const deps: Record<string, string[]> = {};
-    nodes.forEach(n => deps[n.id] = []);
-    edges.forEach(e => {
-        if (deps[e.target]) {
-            deps[e.target].push(e.source);
-        }
-    });
-
-    // 2. Collect all required nodes (transitive closure of dependencies for targets)
-    const required = new Set<string>();
-    const visit = (nodeId: string) => {
-        if (required.has(nodeId)) return;
-        required.add(nodeId);
-        (deps[nodeId] || []).forEach(visit);
-    };
-    targets.forEach(visit);
-
-    // 3. Topological Sort of the subgraph
-    const sorted: string[] = [];
-    const visited = new Set<string>();
-    const tempVisited = new Set<string>();
-
-    const sortVisit = (nodeId: string) => {
-        if (tempVisited.has(nodeId)) {
-            throw new Error(`Cycle detected involving node ${nodeId}`);
-        }
-        if (visited.has(nodeId)) return;
-
-        tempVisited.add(nodeId);
-        (deps[nodeId] || []).forEach(depId => {
-            if (required.has(depId)) {
-                sortVisit(depId);
-            }
-        });
-        tempVisited.delete(nodeId);
-        visited.add(nodeId);
-        sorted.push(nodeId);
-    };
+  // 1. Build dependency graph (reverse adjacency list)
+  // node -> [dependencies]
+  const deps: Record<string, string[]> = {};
+  for (const n of nodes) {
+    deps[n.id] = [];
+  }
+  edges.forEach((e) => {
+    if (deps[e.target]) {
+      deps[e.target].push(e.source);
+    }
+  });
+
+  // 2. Collect all required nodes (transitive closure of dependencies for targets)
+  const required = new Set<string>();
+  const visit = (nodeId: string) => {
+    if (required.has(nodeId)) return;
+    required.add(nodeId);
+    (deps[nodeId] || []).forEach(visit);
+  };
+  targets.forEach(visit);
+
+  // 3. Topological Sort of the subgraph
+  const sorted: string[] = [];
+  const visited = new Set<string>();
+  const tempVisited = new Set<string>();
+
+  const sortVisit = (nodeId: string) => {
+    if (tempVisited.has(nodeId)) {
+      throw new Error(`Cycle detected involving node ${nodeId}`);
+    }
+    if (visited.has(nodeId)) return;
 
-    // Sort only the required nodes
-    required.forEach(nodeId => {
-        if (!visited.has(nodeId)) {
-            sortVisit(nodeId);
-        }
+    tempVisited.add(nodeId);
+    (deps[nodeId] || []).forEach((depId) => {
+      if (required.has(depId)) {
+        sortVisit(depId);
+      }
     });
+    tempVisited.delete(nodeId);
+    visited.add(nodeId);
+    sorted.push(nodeId);
+  };
+
+  // Sort only the required nodes
+  required.forEach((nodeId) => {
+    if (!visited.has(nodeId)) {
+      sortVisit(nodeId);
+    }
+  });
 
-    return sorted;
+  return sorted;
 };
 
 /**
  * Analyzes paths for each target to support multi-color visualization.
  * Returns a map of Node/Edge ID -> List of Target IDs that depend on it.
  */
-export const analyzePaths = (nodes: Node[], edges: Edge[], targets: string[]): Record<string, string[]> => {
-    // Build dependency graph
-    const deps: Record<string, string[]> = {};
-    const edgeDeps: Record<string, string[]> = {}; // node -> incoming edges
-
-    nodes.forEach(n => deps[n.id] = []);
-    edges.forEach(e => {
-        if (!deps[e.target]) deps[e.target] = [];
-        deps[e.target].push(e.source);
-
-        if (!edgeDeps[e.target]) edgeDeps[e.target] = [];
-        edgeDeps[e.target].push(e.id);
-    });
-
-    const itemToTargets: Record<string, string[]> = {};
-
-    // Helper to add target to item
-    const add = (itemId: string, targetId: string) => {
-        if (!itemToTargets[itemId]) itemToTargets[itemId] = [];
-        if (!itemToTargets[itemId].includes(targetId)) {
-            itemToTargets[itemId].push(targetId);
-        }
-    };
+export const analyzePaths = (
+  nodes: Node[],
+  edges: Edge[],
+  targets: string[],
+): Record<string, string[]> => {
+  // Build dependency graph
+  const deps: Record<string, string[]> = {};
+  const edgeDeps: Record<string, string[]> = {}; // node -> incoming edges
+
+  for (const n of nodes) {
+    deps[n.id] = [];
+  }
+  edges.forEach((e) => {
+    if (!deps[e.target]) deps[e.target] = [];
+    deps[e.target].push(e.source);
+
+    if (!edgeDeps[e.target]) edgeDeps[e.target] = [];
+    edgeDeps[e.target].push(e.id);
+  });
+
+  const itemToTargets: Record<string, string[]> = {};
+
+  // Helper to add target to item
+  const add = (itemId: string, targetId: string) => {
+    if (!itemToTargets[itemId]) itemToTargets[itemId] = [];
+    if (!itemToTargets[itemId].includes(targetId)) {
+      itemToTargets[itemId].push(targetId);
+    }
+  };
 
-    // For each target, traverse backwards
-    targets.forEach(targetId => {
-        const visited = new Set<string>();
-        const queue = [targetId];
+  // For each target, traverse backwards
+  targets.forEach((targetId) => {
+    const visited = new Set<string>();
+    const queue = [targetId];
 
-        while (queue.length > 0) {
-            const curr = queue.shift()!;
-            if (visited.has(curr)) continue;
-            visited.add(curr);
+    while (queue.length > 0) {
+      const curr = queue.shift();
+      if (curr === undefined) break;
+      if (visited.has(curr)) continue;
+      visited.add(curr);
 
-            add(curr, targetId);
+      add(curr, targetId);
 
-            // Add incoming edges to this path
-            (edgeDeps[curr] || []).forEach(edgeId => add(edgeId, targetId));
+      // Add incoming edges to this path
+      for (const edgeId of edgeDeps[curr] || []) {
+        add(edgeId, targetId);
+      }
 
-            // Continue to dependencies
-            (deps[curr] || []).forEach(dep => queue.push(dep));
-        }
-    });
+      // Continue to dependencies
+      for (const dep of deps[curr] || []) {
+        queue.push(dep);
+      }
+    }
+  });
 
-    return itemToTargets;
+  return itemToTargets;
 };
diff --git a/ui/src/plugins/contribution-runtime.ts b/ui/src/plugins/contribution-runtime.ts
new file mode 100644
index 00000000..dedba2b1
--- /dev/null
+++ b/ui/src/plugins/contribution-runtime.ts
@@ -0,0 +1,57 @@
+import type { RendererKey } from "@/app/types";
+import { ContributionRegistry } from "@/lib/contribution-registry";
+import type {
+  FilePreviewPlugin,
+  RendererContribution,
+  RendererResolutionContext,
+} from "@/plugins/types";
+import { buildRendererRegistryKey } from "@/plugins/types";
+
+const rendererRegistry = new ContributionRegistry<RendererContribution>("Renderer contribution");
+const filePreviewRegistry = new ContributionRegistry<FilePreviewPlugin>("File preview plugin");
+
+export const registerRendererContribution = (contribution: RendererContribution): void => {
+  rendererRegistry.register(contribution);
+};
+
+export const resolveRendererContribution = (
+  key: RendererKey,
+  context?: Omit<RendererResolutionContext, "key">,
+): RendererContribution | null => {
+  const registryKey = buildRendererRegistryKey(key);
+
+  const matches = rendererRegistry
+    .getAll()
+    .filter((contribution) => buildRendererRegistryKey(contribution.key) === registryKey)
+    .filter((contribution) => {
+      if (!contribution.matches) {
+        return true;
+      }
+      if (!context) {
+        return false;
+      }
+      return contribution.matches({ key, ...context });
+    })
+    .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0));
+
+  return matches[0] ?? null;
+};
+
+export const registerFilePreviewContribution = (plugin: FilePreviewPlugin): void => {
+  filePreviewRegistry.register(plugin, { onDuplicate: "skip" });
+};
+
+export const unregisterFilePreviewContribution = (pluginId: string): boolean => {
+  return filePreviewRegistry.unregister(pluginId);
+};
+
+export const listFilePreviewContributions = (): FilePreviewPlugin[] => {
+  return filePreviewRegistry
+    .getAll()
+    .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0));
+};
+
+export const resetContributionRuntimeForTests = (): void => {
+  rendererRegistry.clear();
+  filePreviewRegistry.clear();
+};
diff --git a/ui/src/plugins/core/index.ts b/ui/src/plugins/core/index.ts
new file mode 100644
index 00000000..613aab02
--- /dev/null
+++ b/ui/src/plugins/core/index.ts
@@ -0,0 +1,34 @@
+import { MarkdownPreview } from "@/components/previews/MarkdownPreview";
+import { WorkflowPreview } from "@/components/previews/WorkflowPreview";
+import { filePreviewPluginRegistry } from "@/lib/file-preview-plugins";
+import type { UiPluginModule } from "@/plugins/types";
+import { registerDefaultRenderers } from "@/app/renderers/registerRenderers";
+
+const corePlugin: UiPluginModule = {
+  id: "core",
+  register: () => {
+    registerDefaultRenderers();
+
+    filePreviewPluginRegistry.register({
+      id: "core:markdown-preview",
+      name: "Markdown Preview",
+      extensions: [".md", ".markdown"],
+      priority: 20,
+      Component: MarkdownPreview,
+    });
+
+    filePreviewPluginRegistry.register({
+      id: "core:workflow-preview",
+      name: "Workflow Preview",
+      extensions: [],
+      priority: 30,
+      canHandle: ({ name, path }) => {
+        const candidate = `${name} ${path}`.toLowerCase();
+        return candidate.includes("workflow.");
+      },
+      Component: WorkflowPreview,
+    });
+  },
+};
+
+export default corePlugin;
diff --git a/ui/src/plugins/molq/MolqRunInspector.tsx b/ui/src/plugins/molq/MolqRunInspector.tsx
new file mode 100644
index 00000000..8fbac5c2
--- /dev/null
+++ b/ui/src/plugins/molq/MolqRunInspector.tsx
@@ -0,0 +1,45 @@
+import { ServerCog } from "lucide-react";
+import { useMemo } from "react";
+import { MetadataInspector } from "@/app/renderers/MetadataInspector";
+import type { RendererProps } from "@/app/types";
+import { Badge } from "@/components/ui/badge";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+
+export const MolqRunInspector = (props: RendererProps): JSX.Element => {
+  const run = useMemo(() => {
+    return props.snapshot.runs.find((item) => item.id === props.selection.objectId) ?? null;
+  }, [props.selection.objectId, props.snapshot.runs]);
+
+  if (!run || run.executorInfo.backend !== "molq") {
+    return <MetadataInspector {...props} />;
+  }
+
+  const rows = Object.entries(run.executorInfo);
+
+  return (
+    <Card className="h-full border-cyan-500/20 bg-cyan-50/40">
+      <CardHeader className="space-y-3">
+        <div className="flex items-center justify-between">
+          <CardTitle className="flex items-center gap-2 text-base font-semibold">
+            <ServerCog className="h-4 w-4 text-cyan-700" />
+            Molq Inspector
+          </CardTitle>
+          <Badge className="bg-cyan-600 text-white hover:bg-cyan-700">scheduler</Badge>
+        </div>
+        <p className="text-xs text-muted-foreground">
+          Normalized executor metadata emitted by the molq backend.
+        </p>
+      </CardHeader>
+      <CardContent className="space-y-3 pt-1">
+        {rows.map(([key, value]) => (
+          <div key={key} className="space-y-1">
+            <p className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">
+              {key}
+            </p>
+            <p className="font-mono text-xs text-foreground">{value}</p>
+          </div>
+        ))}
+      </CardContent>
+    </Card>
+  );
+};
diff --git a/ui/src/plugins/molq/MolqRunViewer.tsx b/ui/src/plugins/molq/MolqRunViewer.tsx
new file mode 100644
index 00000000..a8c219dd
--- /dev/null
+++ b/ui/src/plugins/molq/MolqRunViewer.tsx
@@ -0,0 +1,232 @@
+import {
+  Activity,
+  Boxes,
+  Clock3,
+  Cpu,
+  ExternalLink,
+  ServerCog,
+  TerminalSquare,
+} from "lucide-react";
+import { useMemo } from "react";
+import { RunSnapshotPanel } from "@/app/renderers/SnapshotViewer";
+import { RunViewer } from "@/app/renderers/RunViewer";
+import type { RendererProps } from "@/app/types";
+import { Badge } from "@/components/ui/badge";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+
+const getExecutorEntry = (executorInfo: Record<string, string>, ...keys: string[]): string | null => {
+  for (const key of keys) {
+    const value = executorInfo[key];
+    if (value) {
+      return value;
+    }
+  }
+  return null;
+};
+
+export const MolqRunViewer = (props: RendererProps): JSX.Element => {
+  const run = useMemo(() => {
+    return props.snapshot.runs.find((item) => item.id === props.selection.objectId) ?? null;
+  }, [props.selection.objectId, props.snapshot.runs]);
+
+  if (!run) {
+    return <div className="p-8 text-muted-foreground">Run not found.</div>;
+  }
+
+  if (run.executorInfo.backend !== "molq") {
+    return <RunViewer {...props} />;
+  }
+
+  const scheduler = getExecutorEntry(run.executorInfo, "scheduler") ?? "unknown";
+  const cluster = getExecutorEntry(run.executorInfo, "cluster_name", "cluster") ?? "default";
+  const jobId = getExecutorEntry(run.executorInfo, "job_id", "molq_job_id") ?? "pending";
+  const schedulerJobId =
+    getExecutorEntry(run.executorInfo, "scheduler_job_id", "slurm_job_id") ?? "not assigned";
+
+  const details = Object.entries(run.executorInfo);
+
+  return (
+    <div className="flex h-full flex-col bg-background">
+      <div className="border-b border-border/60 bg-slate-950 px-8 py-8 text-slate-50">
+        <div className="flex flex-wrap items-start justify-between gap-6">
+          <div className="space-y-3">
+            <div className="flex items-center gap-3">
+              <div className="rounded-xl border border-cyan-400/30 bg-cyan-500/10 p-3">
+                <ServerCog className="h-6 w-6 text-cyan-300" />
+              </div>
+              <div>
+                <div className="flex items-center gap-2">
+                  <h1 className="text-3xl font-semibold tracking-tight">{run.name}</h1>
+                  <Badge className="bg-cyan-400/15 text-cyan-100 hover:bg-cyan-400/20">molq</Badge>
+                </div>
+                <p className="mt-1 text-sm text-slate-300">
+                  Scheduler-backed execution routed through molq.
+                </p>
+              </div>
+            </div>
+            <div className="flex flex-wrap items-center gap-2 text-xs uppercase tracking-[0.2em] text-slate-400">
+              <span>{scheduler}</span>
+              <span className="text-slate-600">/</span>
+              <span>{cluster}</span>
+              <span className="text-slate-600">/</span>
+              <span>{run.status}</span>
+            </div>
+          </div>
+
+          <div className="grid min-w-[320px] grid-cols-2 gap-3">
+            <Card className="border-cyan-500/20 bg-slate-900/80 text-slate-50">
+              <CardHeader className="pb-2">
+                <CardTitle className="flex items-center gap-2 text-sm font-medium text-slate-300">
+                  <Cpu className="h-4 w-4 text-cyan-300" />
+                  Scheduler
+                </CardTitle>
+              </CardHeader>
+              <CardContent className="text-2xl font-semibold">{scheduler}</CardContent>
+            </Card>
+            <Card className="border-cyan-500/20 bg-slate-900/80 text-slate-50">
+              <CardHeader className="pb-2">
+                <CardTitle className="flex items-center gap-2 text-sm font-medium text-slate-300">
+                  <Boxes className="h-4 w-4 text-cyan-300" />
+                  Cluster
+                </CardTitle>
+              </CardHeader>
+              <CardContent className="text-2xl font-semibold">{cluster}</CardContent>
+            </Card>
+          </div>
+        </div>
+      </div>
+
+      <div className="flex-1 overflow-hidden">
+        <Tabs defaultValue="overview" className="flex h-full flex-col">
+          <div className="border-b border-border/60 px-8 py-3">
+            <TabsList className="h-auto w-fit rounded-lg bg-muted/30 p-1">
+              <TabsTrigger value="overview">Overview</TabsTrigger>
+              <TabsTrigger value="scheduler">Scheduler</TabsTrigger>
+              <TabsTrigger value="snapshot">Snapshot</TabsTrigger>
+            </TabsList>
+          </div>
+
+          <TabsContent value="overview" className="m-0 flex-1 overflow-auto p-8">
+            <div className="grid gap-4 lg:grid-cols-3">
+              <Card className="border-border/60">
+                <CardHeader className="pb-2">
+                  <CardTitle className="flex items-center gap-2 text-sm">
+                    <TerminalSquare className="h-4 w-4 text-cyan-600" />
+                    Molq Job
+                  </CardTitle>
+                </CardHeader>
+                <CardContent className="space-y-2">
+                  <p className="font-mono text-sm">{jobId}</p>
+                  <p className="text-xs text-muted-foreground">Logical molq job identifier.</p>
+                </CardContent>
+              </Card>
+              <Card className="border-border/60">
+                <CardHeader className="pb-2">
+                  <CardTitle className="flex items-center gap-2 text-sm">
+                    <ExternalLink className="h-4 w-4 text-cyan-600" />
+                    Scheduler Job
+                  </CardTitle>
+                </CardHeader>
+                <CardContent className="space-y-2">
+                  <p className="font-mono text-sm">{schedulerJobId}</p>
+                  <p className="text-xs text-muted-foreground">
+                    Native scheduler identifier exposed by the backend.
+                  </p>
+                </CardContent>
+              </Card>
+              <Card className="border-border/60">
+                <CardHeader className="pb-2">
+                  <CardTitle className="flex items-center gap-2 text-sm">
+                    <Clock3 className="h-4 w-4 text-cyan-600" />
+                    Last Update
+                  </CardTitle>
+                </CardHeader>
+                <CardContent className="space-y-2">
+                  <p className="text-sm font-medium">
+                    {new Date(run.updatedAt).toLocaleString()}
+                  </p>
+                  <p className="text-xs text-muted-foreground">
+                    Latest timestamp available in the workspace snapshot.
+                  </p>
+                </CardContent>
+              </Card>
+            </div>
+
+            <div className="mt-6 grid gap-4 lg:grid-cols-[1.5fr_1fr]">
+              <Card className="border-border/60">
+                <CardHeader>
+                  <CardTitle className="flex items-center gap-2 text-base">
+                    <Activity className="h-4 w-4 text-cyan-600" />
+                    Dispatch Summary
+                  </CardTitle>
+                </CardHeader>
+                <CardContent className="space-y-4 text-sm">
+                  <p className="text-muted-foreground">
+                    {run.summary || "This run is managed by the molq execution backend."}
+                  </p>
+                  <div className="rounded-lg border border-dashed border-border/60 bg-muted/20 p-4">
+                    <div className="grid gap-2 sm:grid-cols-2">
+                      <div>
+                        <p className="text-xs uppercase tracking-wide text-muted-foreground">
+                          Backend
+                        </p>
+                        <p className="font-medium">{run.executorInfo.backend}</p>
+                      </div>
+                      <div>
+                        <p className="text-xs uppercase tracking-wide text-muted-foreground">
+                          Status
+                        </p>
+                        <p className="font-medium">{run.status}</p>
+                      </div>
+                    </div>
+                  </div>
+                </CardContent>
+              </Card>
+
+              <Card className="border-border/60">
+                <CardHeader>
+                  <CardTitle className="text-base">Normalized Executor Info</CardTitle>
+                </CardHeader>
+                <CardContent className="space-y-3">
+                  {details.map(([key, value]) => (
+                    <div key={key} className="space-y-1">
+                      <p className="text-xs uppercase tracking-wide text-muted-foreground">
+                        {key}
+                      </p>
+                      <p className="font-mono text-xs text-foreground">{value}</p>
+                    </div>
+                  ))}
+                </CardContent>
+              </Card>
+            </div>
+          </TabsContent>
+
+          <TabsContent value="scheduler" className="m-0 flex-1 overflow-auto p-8">
+            <Card className="border-border/60">
+              <CardHeader>
+                <CardTitle>Scheduler Metadata</CardTitle>
+              </CardHeader>
+              <CardContent className="overflow-auto">
+                <table className="w-full text-left text-sm">
+                  <tbody className="divide-y divide-border/50">
+                    {details.map(([key, value]) => (
+                      <tr key={key}>
+                        <td className="w-[220px] py-3 font-medium text-muted-foreground">{key}</td>
+                        <td className="py-3 font-mono text-xs">{value}</td>
+                      </tr>
+                    ))}
+                  </tbody>
+                </table>
+              </CardContent>
+            </Card>
+          </TabsContent>
+
+          <TabsContent value="snapshot" className="m-0 flex-1 overflow-hidden">
+            <RunSnapshotPanel runId={run.id} />
+          </TabsContent>
+        </Tabs>
+      </div>
+    </div>
+  );
+};
diff --git a/ui/src/plugins/molq/index.ts b/ui/src/plugins/molq/index.ts
new file mode 100644
index 00000000..9588a977
--- /dev/null
+++ b/ui/src/plugins/molq/index.ts
@@ -0,0 +1,46 @@
+import { registerRendererContribution } from "@/app/registry";
+import { MolqRunInspector } from "@/plugins/molq/MolqRunInspector";
+import { MolqRunViewer } from "@/plugins/molq/MolqRunViewer";
+import type { UiPluginModule } from "@/plugins/types";
+
+const isMolqRun = (runId: string, runs: Array<{ id: string; executorInfo: Record<string, string> }>) => {
+  const run = runs.find((item) => item.id === runId);
+  return run?.executorInfo.backend === "molq";
+};
+
+const molqPlugin: UiPluginModule = {
+  id: "molq",
+  register: () => {
+    registerRendererContribution({
+      id: "molq:run-viewer",
+      key: {
+        objectType: "run",
+        fileKind: "json",
+        contentType: "metadata",
+        panelKind: "viewer",
+      },
+      title: "Molq Run Monitor",
+      panelSlot: "center",
+      priority: 100,
+      matches: ({ selection, snapshot }) => isMolqRun(selection.objectId, snapshot.runs),
+      Component: MolqRunViewer,
+    });
+
+    registerRendererContribution({
+      id: "molq:run-inspector",
+      key: {
+        objectType: "run",
+        fileKind: "json",
+        contentType: "metadata",
+        panelKind: "inspector",
+      },
+      title: "Molq Run Inspector",
+      panelSlot: "right",
+      priority: 100,
+      matches: ({ selection, snapshot }) => isMolqRun(selection.objectId, snapshot.runs),
+      Component: MolqRunInspector,
+    });
+  },
+};
+
+export default molqPlugin;
diff --git a/ui/src/plugins/runtime.ts b/ui/src/plugins/runtime.ts
new file mode 100644
index 00000000..06cdad02
--- /dev/null
+++ b/ui/src/plugins/runtime.ts
@@ -0,0 +1,68 @@
+import { resetContributionRuntimeForTests } from "@/plugins/contribution-runtime";
+import type { PluginManifest, UiPluginModule } from "@/plugins/types";
+
+const builtinPluginLoaders: Record<string, () => Promise<{ default: UiPluginModule }>> = {
+  core: () => import("@/plugins/core"),
+  molq: () => import("@/plugins/molq"),
+};
+
+const installedPlugins = new Set<string>();
+let initializationPromise: Promise<void> | null = null;
+
+const loadBuiltinPlugin = async (moduleId: string): Promise<void> => {
+  if (installedPlugins.has(moduleId)) {
+    return;
+  }
+
+  const loader = builtinPluginLoaders[moduleId];
+  if (!loader) {
+    console.warn(`[plugins] No builtin module registered for "${moduleId}".`);
+    return;
+  }
+
+  const module = await loader();
+  await module.default.register();
+  installedPlugins.add(moduleId);
+  installedPlugins.add(module.default.id);
+};
+
+const fetchPluginManifests = async (): Promise<PluginManifest[]> => {
+  const response = await fetch("/api/plugins");
+  if (!response.ok) {
+    throw new Error(`Plugin manifest request failed: ${response.status}`);
+  }
+
+  const payload = (await response.json()) as { plugins?: PluginManifest[] };
+  return payload.plugins ?? [];
+};
+
+export const initializeUiPlugins = async (): Promise<void> => {
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+
+  initializationPromise = (async () => {
+    await loadBuiltinPlugin("core");
+
+    try {
+      const manifests = await fetchPluginManifests();
+      for (const manifest of manifests) {
+        const moduleId = manifest.uiModule ?? manifest.id;
+        if (moduleId === "core") {
+          continue;
+        }
+        await loadBuiltinPlugin(moduleId);
+      }
+    } catch (error) {
+      console.warn("[plugins] Failed to load plugin manifests. Continuing with core UI only.", error);
+    }
+  })();
+
+  return initializationPromise;
+};
+
+export const resetUiPluginsForTests = (): void => {
+  installedPlugins.clear();
+  initializationPromise = null;
+  resetContributionRuntimeForTests();
+};
diff --git a/ui/src/plugins/types.ts b/ui/src/plugins/types.ts
new file mode 100644
index 00000000..9c09ab76
--- /dev/null
+++ b/ui/src/plugins/types.ts
@@ -0,0 +1,72 @@
+import type React from "react";
+import type {
+  ContentType,
+  FileKind,
+  PanelKind,
+  RendererKey,
+  RendererProps,
+  Selection,
+  WorkspaceSnapshot,
+} from "@/app/types";
+
+export type PanelSlot = "center" | "right";
+
+export interface RendererEntry {
+  key: RendererKey;
+  title: string;
+  panelSlot: PanelSlot;
+  Component: React.ComponentType<RendererProps>;
+}
+
+export interface RenderTarget {
+  panelKind: PanelKind;
+  contentType: ContentType;
+  fileKind: FileKind;
+}
+
+export interface RendererResolutionContext {
+  key: RendererKey;
+  selection: Selection;
+  snapshot: WorkspaceSnapshot;
+  target: RenderTarget;
+}
+
+export interface RendererContribution extends RendererEntry {
+  id: string;
+  priority?: number;
+  matches?: (context: RendererResolutionContext) => boolean;
+}
+
+export interface FilePreviewContentProps {
+  content: string;
+  name: string;
+  path: string;
+  folderId: string;
+}
+
+export interface FilePreviewPlugin {
+  id: string;
+  name: string;
+  extensions: string[];
+  priority?: number;
+  canHandle?: (props: { name: string; path: string }) => boolean;
+  Component: React.ComponentType<FilePreviewContentProps>;
+}
+
+export interface PluginManifest {
+  id: string;
+  title: string;
+  description: string;
+  uiModule?: string | null;
+  capabilities: string[];
+  metadata: Record<string, unknown>;
+}
+
+export interface UiPluginModule {
+  id: string;
+  register: () => void | Promise<void>;
+}
+
+export const buildRendererRegistryKey = (key: RendererKey): string => {
+  return `${key.objectType}::${key.fileKind}::${key.contentType}::${key.panelKind}`;
+};
diff --git a/ui/src/resolvers/BaseResolver.ts b/ui/src/resolvers/BaseResolver.ts
index 5e03e997..606b72cd 100644
--- a/ui/src/resolvers/BaseResolver.ts
+++ b/ui/src/resolvers/BaseResolver.ts
@@ -1,116 +1,114 @@
 /**
  * Base resolver implementation
- * 
+ *
  * Provides common functionality for all resolvers:
  * - Loading from different source types
  * - Schema validation
  * - Error handling
  */
 
-import type { DocumentResolver } from './DocumentResolver';
-import type { DocumentSource } from './types';
-import { ResolverError } from './types';
-import Ajv from 'ajv';
+import Ajv from "ajv";
+import type { DocumentResolver } from "./DocumentResolver";
+import type { DocumentSource } from "./types";
+import { ResolverError } from "./types";
 
 export abstract class BaseResolver<T> implements DocumentResolver<T> {
-    protected ajv: Ajv;
-    protected schema: object;
-
-    constructor(schema: object) {
-        this.schema = schema;
-        this.ajv = new Ajv({ strict: false });
-    }
-
-    async resolve(source: DocumentSource): Promise<T> {
-        try {
-            const data = await this.loadFromSource(source);
-            return this.validate(data);
-        } catch (error) {
-            if (error instanceof ResolverError) {
-                throw error;
-            }
-            throw new ResolverError(
-                `Failed to resolve document from ${source.type} source`,
-                source,
-                error as Error
-            );
-        }
+  protected ajv: Ajv;
+  protected schema: object;
+
+  constructor(schema: object) {
+    this.schema = schema;
+    this.ajv = new Ajv({ strict: false });
+  }
+
+  async resolve(source: DocumentSource): Promise<T> {
+    try {
+      const data = await this.loadFromSource(source);
+      return this.validate(data);
+    } catch (error) {
+      if (error instanceof ResolverError) {
+        throw error;
+      }
+      throw new ResolverError(
+        `Failed to resolve document from ${source.type} source`,
+        source,
+        error as Error,
+      );
     }
+  }
 
-    validate(data: unknown): T {
-        const valid = this.ajv.validate(this.schema, data);
-
-        if (!valid) {
-            const errors = this.ajv.errors || [];
-            const errorMessages = errors.map(err =>
-                `${err.instancePath}: ${err.message}`
-            ).join('; ');
+  validate(data: unknown): T {
+    const valid = this.ajv.validate(this.schema, data);
 
-            throw new Error(`Schema validation failed: ${errorMessages}`);
-        }
+    if (!valid) {
+      const errors = this.ajv.errors || [];
+      const errorMessages = errors.map((err) => `${err.instancePath}: ${err.message}`).join("; ");
 
-        return data as T;
+      throw new Error(`Schema validation failed: ${errorMessages}`);
     }
 
-    protected async loadFromSource(source: DocumentSource): Promise<unknown> {
-        switch (source.type) {
-            case 'file':
-                return this.loadFromFile(source.path);
-            case 'api':
-                return this.loadFromApi(source.endpoint, source.params);
-            case 'embedded':
-                return this.loadEmbedded(source.parentPath, source.fieldPath);
-            default:
-                throw new Error(`Unknown source type: ${(source as any).type}`);
-        }
+    return data as T;
+  }
+
+  protected async loadFromSource(source: DocumentSource): Promise<unknown> {
+    switch (source.type) {
+      case "file":
+        return this.loadFromFile(source.path);
+      case "api":
+        return this.loadFromApi(source.endpoint, source.params);
+      case "embedded":
+        return this.loadEmbedded(source.parentPath, source.fieldPath);
+      default:
+        throw new Error(`Unknown source type: ${(source as Record<string, unknown>).type}`);
     }
+  }
 
-    protected async loadFromFile(path: string): Promise<unknown> {
-        const response = await fetch(`/api/files?path=${encodeURIComponent(path)}`);
+  protected async loadFromFile(path: string): Promise<unknown> {
+    const response = await fetch(`/api/files?path=${encodeURIComponent(path)}`);
 
-        if (!response.ok) {
-            throw new Error(`Failed to load file: ${path} (${response.status})`);
-        }
-
-        return response.json();
+    if (!response.ok) {
+      throw new Error(`Failed to load file: ${path} (${response.status})`);
     }
 
-    protected async loadFromApi(endpoint: string, params?: Record<string, string>): Promise<unknown> {
-        const url = new URL(endpoint, window.location.origin);
-        if (params) {
-            Object.entries(params).forEach(([key, value]) => {
-                url.searchParams.append(key, value);
-            });
-        }
+    return response.json();
+  }
 
-        const response = await fetch(url.toString());
+  protected async loadFromApi(endpoint: string, params?: Record<string, string>): Promise<unknown> {
+    const url = new URL(endpoint, window.location.origin);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        url.searchParams.append(key, value);
+      });
+    }
 
-        if (!response.ok) {
-            throw new Error(`API request failed: ${endpoint} (${response.status})`);
-        }
+    const response = await fetch(url.toString());
 
-        return response.json();
+    if (!response.ok) {
+      throw new Error(`API request failed: ${endpoint} (${response.status})`);
     }
 
-    protected async loadEmbedded(parentPath: string, fieldPath: string): Promise<unknown> {
-        // Load parent document
-        const parentData = await this.loadFromFile(parentPath);
+    return response.json();
+  }
 
-        // Extract nested field using path (e.g., "context.workflow")
-        const fields = fieldPath.split('.');
-        let current: any = parentData;
+  protected async loadEmbedded(parentPath: string, fieldPath: string): Promise<unknown> {
+    // Load parent document
+    const parentData = await this.loadFromFile(parentPath);
 
-        for (const field of fields) {
-            if (current == null || typeof current !== 'object') {
-                throw new Error(`Invalid field path: ${fieldPath} in ${parentPath}`);
-            }
-            current = current[field];
-        }
+    // Extract nested field using path (e.g., "context.workflow")
+    const fields = fieldPath.split(".");
+    let current: unknown = parentData;
 
-        if (current == null) {
-            throw new Error(`Field not found: ${fieldPath} in ${parentPath}`);
-        }
+    for (const field of fields) {
+      if (current == null || typeof current !== "object") {
+        throw new Error(`Invalid field path: ${fieldPath} in ${parentPath}`);
+      }
+      current = (current as Record<string, unknown>)[field];
+    }
 
-        return current;
+    if (current == null) {
+      throw new Error(`Field not found: ${fieldPath} in ${parentPath}`);
     }
+
+    return current;
+  }
 }
diff --git a/ui/src/resolvers/ContextResolver.ts b/ui/src/resolvers/ContextResolver.ts
index fb1f6fe4..09309e63 100644
--- a/ui/src/resolvers/ContextResolver.ts
+++ b/ui/src/resolvers/ContextResolver.ts
@@ -1,19 +1,19 @@
 /**
  * Context resolver
- * 
+ *
  * Resolves Context from:
  * - run.json files (context field)
  * - checkpoint files
  */
 
-import { BaseResolver } from './BaseResolver';
-import type { Context } from '../types/documents';
-import contextSchema from '@schemas/context.json';
+import contextSchema from "@schemas/context.json";
+import type { Context } from "../types/documents";
+import { BaseResolver } from "./BaseResolver";
 
 export class ContextResolver extends BaseResolver<Context> {
-    constructor() {
-        super(contextSchema);
-    }
+  constructor() {
+    super(contextSchema);
+  }
 }
 
 export const contextResolver = new ContextResolver();
diff --git a/ui/src/resolvers/DocumentResolver.ts b/ui/src/resolvers/DocumentResolver.ts
index a4a181a5..6a455933 100644
--- a/ui/src/resolvers/DocumentResolver.ts
+++ b/ui/src/resolvers/DocumentResolver.ts
@@ -1,28 +1,28 @@
 /**
  * Document resolver interface
- * 
+ *
  * Resolvers extract and validate typed documents from various sources.
  * They are pure extractors with no business logic.
  */
 
-import type { DocumentSource } from './types';
+import type { DocumentSource } from "./types";
 
 export interface DocumentResolver<T> {
-    /**
-     * Resolve document from source
-     * 
-     * @param source - Document source (file, API, embedded)
-     * @returns Validated typed document
-     * @throws ResolverError if resolution or validation fails
-     */
-    resolve(source: DocumentSource): Promise<T>;
+  /**
+   * Resolve document from source
+   *
+   * @param source - Document source (file, API, embedded)
+   * @returns Validated typed document
+   * @throws ResolverError if resolution or validation fails
+   */
+  resolve(source: DocumentSource): Promise<T>;
 
-    /**
-     * Validate document against schema
-     * 
-     * @param data - Raw document data
-     * @returns Validated typed document
-     * @throws ResolverError if validation fails
-     */
-    validate(data: unknown): T;
+  /**
+   * Validate document against schema
+   *
+   * @param data - Raw document data
+   * @returns Validated typed document
+   * @throws ResolverError if validation fails
+   */
+  validate(data: unknown): T;
 }
diff --git a/ui/src/resolvers/WorkflowResolver.ts b/ui/src/resolvers/WorkflowResolver.ts
index 7cc24037..e7f5d135 100644
--- a/ui/src/resolvers/WorkflowResolver.ts
+++ b/ui/src/resolvers/WorkflowResolver.ts
@@ -1,20 +1,20 @@
 /**
  * Workflow resolver
- * 
+ *
  * Resolves WorkflowDoc from:
  * - Standalone workflow.json files
  * - Embedded in run.json (context.workflow)
  * - Embedded in checkpoint files (context.workflow)
  */
 
-import { BaseResolver } from './BaseResolver';
-import type { Workflow } from '../types/documents';
-import workflowSchema from '@schemas/workflow.json';
+import workflowSchema from "@schemas/workflow.json";
+import type { Workflow } from "../types/documents";
+import { BaseResolver } from "./BaseResolver";
 
 export class WorkflowResolver extends BaseResolver<Workflow> {
-    constructor() {
-        super(workflowSchema);
-    }
+  constructor() {
+    super(workflowSchema);
+  }
 }
 
 export const workflowResolver = new WorkflowResolver();
diff --git a/ui/src/resolvers/index.ts b/ui/src/resolvers/index.ts
index 207de1c2..543a6d4b 100644
--- a/ui/src/resolvers/index.ts
+++ b/ui/src/resolvers/index.ts
@@ -2,8 +2,8 @@
  * Resolver exports
  */
 
-export * from './types';
-export * from './DocumentResolver';
-export * from './BaseResolver';
-export * from './WorkflowResolver';
-export * from './ContextResolver';
+export * from "./BaseResolver";
+export * from "./ContextResolver";
+export * from "./DocumentResolver";
+export * from "./types";
+export * from "./WorkflowResolver";
diff --git a/ui/src/resolvers/types.ts b/ui/src/resolvers/types.ts
index 376c2bcd..e95cd0e6 100644
--- a/ui/src/resolvers/types.ts
+++ b/ui/src/resolvers/types.ts
@@ -1,29 +1,29 @@
 /**
  * Document source types for resolver layer
- * 
+ *
  * Defines where documents can be loaded from:
  * - File system paths
  * - Backend API endpoints
  * - Embedded data within parent documents
  */
 
-export type DocumentSourceType = 'file' | 'api' | 'embedded';
+export type DocumentSourceType = "file" | "api" | "embedded";
 
 export interface FileSource {
-    type: 'file';
-    path: string;
+  type: "file";
+  path: string;
 }
 
 export interface ApiSource {
-    type: 'api';
-    endpoint: string;
-    params?: Record<string, string>;
+  type: "api";
+  endpoint: string;
+  params?: Record<string, string>;
 }
 
 export interface EmbeddedSource {
-    type: 'embedded';
-    parentPath: string;
-    fieldPath: string;  // e.g., "context.workflow"
+  type: "embedded";
+  parentPath: string;
+  fieldPath: string; // e.g., "context.workflow"
 }
 
 export type DocumentSource = FileSource | ApiSource | EmbeddedSource;
@@ -32,12 +32,12 @@ export type DocumentSource = FileSource | ApiSource | EmbeddedSource;
  * Resolver error class
  */
 export class ResolverError extends Error {
-    constructor(
-        message: string,
-        public source: DocumentSource,
-        public cause?: Error
-    ) {
-        super(message);
-        this.name = 'ResolverError';
-    }
+  constructor(
+    message: string,
+    public source: DocumentSource,
+    public cause?: Error,
+  ) {
+    super(message);
+    this.name = "ResolverError";
+  }
 }
diff --git a/ui/src/styles/tailwind.css b/ui/src/styles/tailwind.css
index 60ddd9be..c41fb486 100644
--- a/ui/src/styles/tailwind.css
+++ b/ui/src/styles/tailwind.css
@@ -28,6 +28,16 @@
     --color-card: hsl(var(--card));
     --color-card-foreground: hsl(var(--card-foreground));
 
+    --color-success: hsl(var(--success));
+    --color-success-foreground: hsl(var(--success-foreground));
+    --color-success-soft: hsl(var(--success-soft));
+    --color-warning: hsl(var(--warning));
+    --color-warning-foreground: hsl(var(--warning-foreground));
+    --color-warning-soft: hsl(var(--warning-soft));
+    --color-info: hsl(var(--info));
+    --color-info-foreground: hsl(var(--info-foreground));
+    --color-info-soft: hsl(var(--info-soft));
+
     --radius-lg: var(--radius);
     --radius-md: calc(var(--radius) - 2px);
     --radius-sm: calc(var(--radius) - 4px);
@@ -79,6 +89,16 @@
         --input: 240 5.9% 90%;
         --ring: 240 5.9% 10%;
         --radius: 0.5rem;
+
+        --success: 142 72% 29%;
+        --success-foreground: 142 72% 20%;
+        --success-soft: 142 72% 94%;
+        --warning: 38 92% 50%;
+        --warning-foreground: 30 90% 28%;
+        --warning-soft: 38 92% 94%;
+        --info: 217 91% 48%;
+        --info-foreground: 217 91% 30%;
+        --info-soft: 217 91% 95%;
     }
 
     .dark {
@@ -101,6 +121,16 @@
         --border: 240 3.7% 15.9%;
         --input: 240 3.7% 15.9%;
         --ring: 240 4.9% 83.9%;
+
+        --success: 142 60% 45%;
+        --success-foreground: 142 70% 85%;
+        --success-soft: 142 45% 16%;
+        --warning: 38 85% 55%;
+        --warning-foreground: 38 90% 85%;
+        --warning-soft: 38 50% 18%;
+        --info: 217 80% 60%;
+        --info-foreground: 217 80% 88%;
+        --info-soft: 217 60% 18%;
     }
 }
 
diff --git a/ui/src/types/documents.ts b/ui/src/types/documents.ts
index d4c67fd8..119c784e 100644
--- a/ui/src/types/documents.ts
+++ b/ui/src/types/documents.ts
@@ -1,11 +1,8 @@
 export type JsonPrimitive = string | number | boolean | null;
 
-export type JsonValue =
-  | JsonPrimitive
-  | JsonValue[]
-  | { [key: string]: JsonValue };
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
 
-export type TaskStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type TaskStatus = "pending" | "running" | "succeeded" | "failed" | "cancelled";
 
 export interface TaskConfig {
   task_id: string;
diff --git a/ui/src/types/jsx.d.ts b/ui/src/types/jsx.d.ts
new file mode 100644
index 00000000..b0aacd0e
--- /dev/null
+++ b/ui/src/types/jsx.d.ts
@@ -0,0 +1,11 @@
+import type * as React from "react";
+
+declare global {
+  namespace JSX {
+    type Element = React.JSX.Element;
+    interface IntrinsicElements extends React.JSX.IntrinsicElements {}
+    interface IntrinsicAttributes extends React.JSX.IntrinsicAttributes {}
+    interface ElementChildrenAttribute extends React.JSX.ElementChildrenAttribute {}
+    interface LibraryManagedAttributes<C, P> extends React.JSX.LibraryManagedAttributes<C, P> {}
+  }
+}
diff --git a/ui/src/types/task_graph_ir.ts b/ui/src/types/task_graph_ir.ts
new file mode 100644
index 00000000..2f42c745
--- /dev/null
+++ b/ui/src/types/task_graph_ir.ts
@@ -0,0 +1,22 @@
+export interface TaskNodeJson {
+  id: string;
+  type: string;
+  label?: string;
+  config?: Record<string, unknown>;
+  params?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+}
+
+export interface EdgeJson {
+  from: string;
+  to: string;
+  kind?: string;
+}
+
+export interface TaskGraphJson {
+  name: string;
+  nodes: TaskNodeJson[];
+  edges: EdgeJson[];
+  targets?: string[];
+  metadata?: Record<string, unknown>;
+}
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 00000000..717248ad
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,3144 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "ag-ui-protocol"
+version = "0.1.15"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/71/96c21ae7e2fb9b610c1a90d38bd2de8b6e5b2900a63001f3882f43e519af/ag_ui_protocol-0.1.15.tar.gz", hash = "sha256:5e23c1042c7d4e364d685e68d2fb74d37c16bc83c66d270102d8eaedce56ad82", size = 6269, upload-time = "2026-04-01T15:44:33.136Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/a0/a73398d30bb0f9ad70cd70426151a4a19527a7296e48a3a16a50e1d5db05/ag_ui_protocol-0.1.15-py3-none-any.whl", hash = "sha256:85cde077023ccbc37b5ce2ad953537883c262d210320f201fc2ec4e85408b06a", size = 8661, upload-time = "2026-04-01T15:44:32.079Z" },
+]
+
+[[package]]
+name = "aiofile"
+version = "3.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "caio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/67/e2/d7cb819de8df6b5c1968a2756c3cb4122d4fa2b8fc768b53b7c9e5edb646/aiofile-3.9.0.tar.gz", hash = "sha256:e5ad718bb148b265b6df1b3752c4d1d83024b93da9bd599df74b9d9ffcf7919b", size = 17943, upload-time = "2024-10-08T10:39:35.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/50/25/da1f0b4dd970e52bf5a36c204c107e11a0c6d3ed195eba0bfbc664c312b2/aiofile-3.9.0-py3-none-any.whl", hash = "sha256:ce2f6c1571538cbdfa0143b04e16b208ecb0e9cb4148e528af8a640ed51cc8aa", size = 19539, upload-time = "2024-10-08T10:39:32.955Z" },
+]
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/77/9a/152096d4808df8e4268befa55fba462f440f14beab85e8ad9bf990516918/aiohttp-3.13.5.tar.gz", hash = "sha256:9d98cc980ecc96be6eb4c1994ce35d28d8b1f5e5208a23b421187d1209dbb7d1", size = 7858271, upload-time = "2026-03-31T22:01:03.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/6f/353954c29e7dcce7cf00280a02c75f30e133c00793c7a2ed3776d7b2f426/aiohttp-3.13.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:023ecba036ddd840b0b19bf195bfae970083fd7024ce1ac22e9bba90464620e9", size = 748876, upload-time = "2026-03-31T21:57:36.319Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/1b/428a7c64687b3b2e9cd293186695affc0e1e54a445d0361743b231f11066/aiohttp-3.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15c933ad7920b7d9a20de151efcd05a6e38302cbf0e10c9b2acb9a42210a2416", size = 499557, upload-time = "2026-03-31T21:57:38.236Z" },
+    { url = "https://files.pythonhosted.org/packages/29/47/7be41556bfbb6917069d6a6634bb7dd5e163ba445b783a90d40f5ac7e3a7/aiohttp-3.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab2899f9fa2f9f741896ebb6fa07c4c883bfa5c7f2ddd8cf2aafa86fa981b2d2", size = 500258, upload-time = "2026-03-31T21:57:39.923Z" },
+    { url = "https://files.pythonhosted.org/packages/67/84/c9ecc5828cb0b3695856c07c0a6817a99d51e2473400f705275a2b3d9239/aiohttp-3.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60eaa2d440cd4707696b52e40ed3e2b0f73f65be07fd0ef23b6b539c9c0b0b4", size = 1749199, upload-time = "2026-03-31T21:57:41.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/d3/3c6d610e66b495657622edb6ae7c7fd31b2e9086b4ec50b47897ad6042a9/aiohttp-3.13.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:55b3bdd3292283295774ab585160c4004f4f2f203946997f49aac032c84649e9", size = 1721013, upload-time = "2026-03-31T21:57:43.904Z" },
+    { url = "https://files.pythonhosted.org/packages/49/a0/24409c12217456df0bae7babe3b014e460b0b38a8e60753d6cb339f6556d/aiohttp-3.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2b2355dc094e5f7d45a7bb262fe7207aa0460b37a0d87027dcf21b5d890e7d5", size = 1781501, upload-time = "2026-03-31T21:57:46.285Z" },
+    { url = "https://files.pythonhosted.org/packages/98/9d/b65ec649adc5bccc008b0957a9a9c691070aeac4e41cea18559fef49958b/aiohttp-3.13.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b38765950832f7d728297689ad78f5f2cf79ff82487131c4d26fe6ceecdc5f8e", size = 1878981, upload-time = "2026-03-31T21:57:48.734Z" },
+    { url = "https://files.pythonhosted.org/packages/57/d8/8d44036d7eb7b6a8ec4c5494ea0c8c8b94fbc0ed3991c1a7adf230df03bf/aiohttp-3.13.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b18f31b80d5a33661e08c89e202edabf1986e9b49c42b4504371daeaa11b47c1", size = 1767934, upload-time = "2026-03-31T21:57:51.171Z" },
+    { url = "https://files.pythonhosted.org/packages/31/04/d3f8211f273356f158e3464e9e45484d3fb8c4ce5eb2f6fe9405c3273983/aiohttp-3.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:33add2463dde55c4f2d9635c6ab33ce154e5ecf322bd26d09af95c5f81cfa286", size = 1566671, upload-time = "2026-03-31T21:57:53.326Z" },
+    { url = "https://files.pythonhosted.org/packages/41/db/073e4ebe00b78e2dfcacff734291651729a62953b48933d765dc513bf798/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:327cc432fdf1356fb4fbc6fe833ad4e9f6aacb71a8acaa5f1855e4b25910e4a9", size = 1705219, upload-time = "2026-03-31T21:57:55.385Z" },
+    { url = "https://files.pythonhosted.org/packages/48/45/7dfba71a2f9fd97b15c95c06819de7eb38113d2cdb6319669195a7d64270/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7c35b0bf0b48a70b4cb4fc5d7bed9b932532728e124874355de1a0af8ec4bc88", size = 1743049, upload-time = "2026-03-31T21:57:57.341Z" },
+    { url = "https://files.pythonhosted.org/packages/18/71/901db0061e0f717d226386a7f471bb59b19566f2cae5f0d93874b017271f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:df23d57718f24badef8656c49743e11a89fd6f5358fa8a7b96e728fda2abf7d3", size = 1749557, upload-time = "2026-03-31T21:57:59.626Z" },
+    { url = "https://files.pythonhosted.org/packages/08/d5/41eebd16066e59cd43728fe74bce953d7402f2b4ddfdfef2c0e9f17ca274/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:02e048037a6501a5ec1f6fc9736135aec6eb8a004ce48838cb951c515f32c80b", size = 1558931, upload-time = "2026-03-31T21:58:01.972Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e6/4a799798bf05740e66c3a1161079bda7a3dd8e22ca392481d7a7f9af82a6/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31cebae8b26f8a615d2b546fee45d5ffb76852ae6450e2a03f42c9102260d6fe", size = 1774125, upload-time = "2026-03-31T21:58:04.007Z" },
+    { url = "https://files.pythonhosted.org/packages/84/63/7749337c90f92bc2cb18f9560d67aa6258c7060d1397d21529b8004fcf6f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:888e78eb5ca55a615d285c3c09a7a91b42e9dd6fc699b166ebd5dee87c9ccf14", size = 1732427, upload-time = "2026-03-31T21:58:06.337Z" },
+    { url = "https://files.pythonhosted.org/packages/98/de/cf2f44ff98d307e72fb97d5f5bbae3bfcb442f0ea9790c0bf5c5c2331404/aiohttp-3.13.5-cp312-cp312-win32.whl", hash = "sha256:8bd3ec6376e68a41f9f95f5ed170e2fcf22d4eb27a1f8cb361d0508f6e0557f3", size = 433534, upload-time = "2026-03-31T21:58:08.712Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ca/eadf6f9c8fa5e31d40993e3db153fb5ed0b11008ad5d9de98a95045bed84/aiohttp-3.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:110e448e02c729bcebb18c60b9214a87ba33bac4a9fa5e9a5f139938b56c6cb1", size = 460446, upload-time = "2026-03-31T21:58:10.945Z" },
+    { url = "https://files.pythonhosted.org/packages/78/e9/d76bf503005709e390122d34e15256b88f7008e246c4bdbe915cd4f1adce/aiohttp-3.13.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5029cc80718bbd545123cd8fe5d15025eccaaaace5d0eeec6bd556ad6163d61", size = 742930, upload-time = "2026-03-31T21:58:13.155Z" },
+    { url = "https://files.pythonhosted.org/packages/57/00/4b7b70223deaebd9bb85984d01a764b0d7bd6526fcdc73cca83bcbe7243e/aiohttp-3.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4bb6bf5811620003614076bdc807ef3b5e38244f9d25ca5fe888eaccea2a9832", size = 496927, upload-time = "2026-03-31T21:58:15.073Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/f5/0fb20fb49f8efdcdce6cd8127604ad2c503e754a8f139f5e02b01626523f/aiohttp-3.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a84792f8631bf5a94e52d9cc881c0b824ab42717165a5579c760b830d9392ac9", size = 497141, upload-time = "2026-03-31T21:58:17.009Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/86/b7c870053e36a94e8951b803cb5b909bfbc9b90ca941527f5fcafbf6b0fa/aiohttp-3.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:57653eac22c6a4c13eb22ecf4d673d64a12f266e72785ab1c8b8e5940d0e8090", size = 1732476, upload-time = "2026-03-31T21:58:18.925Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e5/4e161f84f98d80c03a238671b4136e6530453d65262867d989bbe78244d0/aiohttp-3.13.5-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5e5f7debc7a57af53fdf5c5009f9391d9f4c12867049d509bf7bb164a6e295b", size = 1706507, upload-time = "2026-03-31T21:58:21.094Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/56/ea11a9f01518bd5a2a2fcee869d248c4b8a0cfa0bb13401574fa31adf4d4/aiohttp-3.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c719f65bebcdf6716f10e9eff80d27567f7892d8988c06de12bbbd39307c6e3a", size = 1773465, upload-time = "2026-03-31T21:58:23.159Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/40/333ca27fb74b0383f17c90570c748f7582501507307350a79d9f9f3c6eb1/aiohttp-3.13.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d97f93fdae594d886c5a866636397e2bcab146fd7a132fd6bb9ce182224452f8", size = 1873523, upload-time = "2026-03-31T21:58:25.59Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/d2/e2f77eef1acb7111405433c707dc735e63f67a56e176e72e9e7a2cd3f493/aiohttp-3.13.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df334e39d4c2f899a914f1dba283c1aadc311790733f705182998c6f7cae665", size = 1754113, upload-time = "2026-03-31T21:58:27.624Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/56/3f653d7f53c89669301ec9e42c95233e2a0c0a6dd051269e6e678db4fdb0/aiohttp-3.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe6970addfea9e5e081401bcbadf865d2b6da045472f58af08427e108d618540", size = 1562351, upload-time = "2026-03-31T21:58:29.918Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/a6/9b3e91eb8ae791cce4ee736da02211c85c6f835f1bdfac0594a8a3b7018c/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7becdf835feff2f4f335d7477f121af787e3504b48b449ff737afb35869ba7bb", size = 1693205, upload-time = "2026-03-31T21:58:32.214Z" },
+    { url = "https://files.pythonhosted.org/packages/98/fc/bfb437a99a2fcebd6b6eaec609571954de2ed424f01c352f4b5504371dd3/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:676e5651705ad5d8a70aeb8eb6936c436d8ebbd56e63436cb7dd9bb36d2a9a46", size = 1730618, upload-time = "2026-03-31T21:58:34.728Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/b6/c8534862126191a034f68153194c389addc285a0f1347d85096d349bbc15/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:9b16c653d38eb1a611cc898c41e76859ca27f119d25b53c12875fd0474ae31a8", size = 1745185, upload-time = "2026-03-31T21:58:36.909Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/93/4ca8ee2ef5236e2707e0fd5fecb10ce214aee1ff4ab307af9c558bda3b37/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:999802d5fa0389f58decd24b537c54aa63c01c3219ce17d1214cbda3c2b22d2d", size = 1557311, upload-time = "2026-03-31T21:58:39.38Z" },
+    { url = "https://files.pythonhosted.org/packages/57/ae/76177b15f18c5f5d094f19901d284025db28eccc5ae374d1d254181d33f4/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ec707059ee75732b1ba130ed5f9580fe10ff75180c812bc267ded039db5128c6", size = 1773147, upload-time = "2026-03-31T21:58:41.476Z" },
+    { url = "https://files.pythonhosted.org/packages/01/a4/62f05a0a98d88af59d93b7fcac564e5f18f513cb7471696ac286db970d6a/aiohttp-3.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d6d44a5b48132053c2f6cd5c8cb14bc67e99a63594e336b0f2af81e94d5530c", size = 1730356, upload-time = "2026-03-31T21:58:44.049Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/85/fc8601f59dfa8c9523808281f2da571f8b4699685f9809a228adcc90838d/aiohttp-3.13.5-cp313-cp313-win32.whl", hash = "sha256:329f292ed14d38a6c4c435e465f48bebb47479fd676a0411936cc371643225cc", size = 432637, upload-time = "2026-03-31T21:58:46.167Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/1b/ac685a8882896acf0f6b31d689e3792199cfe7aba37969fa91da63a7fa27/aiohttp-3.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:69f571de7500e0557801c0b51f4780482c0ec5fe2ac851af5a92cfce1af1cb83", size = 458896, upload-time = "2026-03-31T21:58:48.119Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ce/46572759afc859e867a5bc8ec3487315869013f59281ce61764f76d879de/aiohttp-3.13.5-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:eb4639f32fd4a9904ab8fb45bf3383ba71137f3d9d4ba25b3b3f3109977c5b8c", size = 745721, upload-time = "2026-03-31T21:58:50.229Z" },
+    { url = "https://files.pythonhosted.org/packages/13/fe/8a2efd7626dbe6049b2ef8ace18ffda8a4dfcbe1bcff3ac30c0c7575c20b/aiohttp-3.13.5-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:7e5dc4311bd5ac493886c63cbf76ab579dbe4641268e7c74e48e774c74b6f2be", size = 497663, upload-time = "2026-03-31T21:58:52.232Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/91/cc8cc78a111826c54743d88651e1687008133c37e5ee615fee9b57990fac/aiohttp-3.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:756c3c304d394977519824449600adaf2be0ccee76d206ee339c5e76b70ded25", size = 499094, upload-time = "2026-03-31T21:58:54.566Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/33/a8362cb15cf16a3af7e86ed11962d5cd7d59b449202dc576cdc731310bde/aiohttp-3.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecc26751323224cf8186efcf7fbcbc30f4e1d8c7970659daf25ad995e4032a56", size = 1726701, upload-time = "2026-03-31T21:58:56.864Z" },
+    { url = "https://files.pythonhosted.org/packages/45/0c/c091ac5c3a17114bd76cbf85d674650969ddf93387876cf67f754204bd77/aiohttp-3.13.5-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10a75acfcf794edf9d8db50e5a7ec5fc818b2a8d3f591ce93bc7b1210df016d2", size = 1683360, upload-time = "2026-03-31T21:58:59.072Z" },
+    { url = "https://files.pythonhosted.org/packages/23/73/bcee1c2b79bc275e964d1446c55c54441a461938e70267c86afaae6fba27/aiohttp-3.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0f7a18f258d124cd678c5fe072fe4432a4d5232b0657fca7c1847f599233c83a", size = 1773023, upload-time = "2026-03-31T21:59:01.776Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/ef/720e639df03004fee2d869f771799d8c23046dec47d5b81e396c7cda583a/aiohttp-3.13.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:df6104c009713d3a89621096f3e3e88cc323fd269dbd7c20afe18535094320be", size = 1853795, upload-time = "2026-03-31T21:59:04.568Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/c9/989f4034fb46841208de7aeeac2c6d8300745ab4f28c42f629ba77c2d916/aiohttp-3.13.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:241a94f7de7c0c3b616627aaad530fe2cb620084a8b144d3be7b6ecfe95bae3b", size = 1730405, upload-time = "2026-03-31T21:59:07.221Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/75/ee1fd286ca7dc599d824b5651dad7b3be7ff8d9a7e7b3fe9820d9180f7db/aiohttp-3.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c974fb66180e58709b6fc402846f13791240d180b74de81d23913abe48e96d94", size = 1558082, upload-time = "2026-03-31T21:59:09.484Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/20/1e9e6650dfc436340116b7aa89ff8cb2bbdf0abc11dfaceaad8f74273a10/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6e27ea05d184afac78aabbac667450c75e54e35f62238d44463131bd3f96753d", size = 1692346, upload-time = "2026-03-31T21:59:12.068Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/40/8ebc6658d48ea630ac7903912fe0dd4e262f0e16825aa4c833c56c9f1f56/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a79a6d399cef33a11b6f004c67bb07741d91f2be01b8d712d52c75711b1e07c7", size = 1698891, upload-time = "2026-03-31T21:59:14.552Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/78/ea0ae5ec8ba7a5c10bdd6e318f1ba5e76fcde17db8275188772afc7917a4/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c632ce9c0b534fbe25b52c974515ed674937c5b99f549a92127c85f771a78772", size = 1742113, upload-time = "2026-03-31T21:59:17.068Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/66/9d308ed71e3f2491be1acb8769d96c6f0c47d92099f3bc9119cada27b357/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fceedde51fbd67ee2bcc8c0b33d0126cc8b51ef3bbde2f86662bd6d5a6f10ec5", size = 1553088, upload-time = "2026-03-31T21:59:19.541Z" },
+    { url = "https://files.pythonhosted.org/packages/da/a6/6cc25ed8dfc6e00c90f5c6d126a98e2cf28957ad06fa1036bd34b6f24a2c/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f92995dfec9420bb69ae629abf422e516923ba79ba4403bc750d94fb4a6c68c1", size = 1757976, upload-time = "2026-03-31T21:59:22.311Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/2b/cce5b0ffe0de99c83e5e36d8f828e4161e415660a9f3e58339d07cce3006/aiohttp-3.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:20ae0ff08b1f2c8788d6fb85afcb798654ae6ba0b747575f8562de738078457b", size = 1712444, upload-time = "2026-03-31T21:59:24.635Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/cf/9e1795b4160c58d29421eafd1a69c6ce351e2f7c8d3c6b7e4ca44aea1a5b/aiohttp-3.13.5-cp314-cp314-win32.whl", hash = "sha256:b20df693de16f42b2472a9c485e1c948ee55524786a0a34345511afdd22246f3", size = 438128, upload-time = "2026-03-31T21:59:27.291Z" },
+    { url = "https://files.pythonhosted.org/packages/22/4d/eaedff67fc805aeba4ba746aec891b4b24cebb1a7d078084b6300f79d063/aiohttp-3.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:f85c6f327bf0b8c29da7d93b1cabb6363fb5e4e160a32fa241ed2dce21b73162", size = 464029, upload-time = "2026-03-31T21:59:29.429Z" },
+    { url = "https://files.pythonhosted.org/packages/79/11/c27d9332ee20d68dd164dc12a6ecdef2e2e35ecc97ed6cf0d2442844624b/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:1efb06900858bb618ff5cee184ae2de5828896c448403d51fb633f09e109be0a", size = 778758, upload-time = "2026-03-31T21:59:31.547Z" },
+    { url = "https://files.pythonhosted.org/packages/04/fb/377aead2e0a3ba5f09b7624f702a964bdf4f08b5b6728a9799830c80041e/aiohttp-3.13.5-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:fee86b7c4bd29bdaf0d53d14739b08a106fdda809ca5fe032a15f52fae5fe254", size = 512883, upload-time = "2026-03-31T21:59:34.098Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/a6/aa109a33671f7a5d3bd78b46da9d852797c5e665bfda7d6b373f56bff2ec/aiohttp-3.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:20058e23909b9e65f9da62b396b77dfa95965cbe840f8def6e572538b1d32e36", size = 516668, upload-time = "2026-03-31T21:59:36.497Z" },
+    { url = "https://files.pythonhosted.org/packages/79/b3/ca078f9f2fa9563c36fb8ef89053ea2bb146d6f792c5104574d49d8acb63/aiohttp-3.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cf20a8d6868cb15a73cab329ffc07291ba8c22b1b88176026106ae39aa6df0f", size = 1883461, upload-time = "2026-03-31T21:59:38.723Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/e3/a7ad633ca1ca497b852233a3cce6906a56c3225fb6d9217b5e5e60b7419d/aiohttp-3.13.5-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:330f5da04c987f1d5bdb8ae189137c77139f36bd1cb23779ca1a354a4b027800", size = 1747661, upload-time = "2026-03-31T21:59:41.187Z" },
+    { url = "https://files.pythonhosted.org/packages/33/b9/cd6fe579bed34a906d3d783fe60f2fa297ef55b27bb4538438ee49d4dc41/aiohttp-3.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f1cbf0c7926d315c3c26c2da41fd2b5d2fe01ac0e157b78caefc51a782196cf", size = 1863800, upload-time = "2026-03-31T21:59:43.84Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/3f/2c1e2f5144cefa889c8afd5cf431994c32f3b29da9961698ff4e3811b79a/aiohttp-3.13.5-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:53fc049ed6390d05423ba33103ded7281fe897cf97878f369a527070bd95795b", size = 1958382, upload-time = "2026-03-31T21:59:46.187Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1d/f31ec3f1013723b3babe3609e7f119c2c2fb6ef33da90061a705ef3e1bc8/aiohttp-3.13.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:898703aa2667e3c5ca4c54ca36cd73f58b7a38ef87a5606414799ebce4d3fd3a", size = 1803724, upload-time = "2026-03-31T21:59:48.656Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b4/57712dfc6f1542f067daa81eb61da282fab3e6f1966fca25db06c4fc62d5/aiohttp-3.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0494a01ca9584eea1e5fbd6d748e61ecff218c51b576ee1999c23db7066417d8", size = 1640027, upload-time = "2026-03-31T21:59:51.284Z" },
+    { url = "https://files.pythonhosted.org/packages/25/3c/734c878fb43ec083d8e31bf029daae1beafeae582d1b35da234739e82ee7/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6cf81fe010b8c17b09495cbd15c1d35afbc8fb405c0c9cf4738e5ae3af1d65be", size = 1806644, upload-time = "2026-03-31T21:59:53.753Z" },
+    { url = "https://files.pythonhosted.org/packages/20/a5/f671e5cbec1c21d044ff3078223f949748f3a7f86b14e34a365d74a5d21f/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:c564dd5f09ddc9d8f2c2d0a301cd30a79a2cc1b46dd1a73bef8f0038863d016b", size = 1791630, upload-time = "2026-03-31T21:59:56.239Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/63/fb8d0ad63a0b8a99be97deac8c04dacf0785721c158bdf23d679a87aa99e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2994be9f6e51046c4f864598fd9abeb4fba6e88f0b2152422c9666dcd4aea9c6", size = 1809403, upload-time = "2026-03-31T21:59:59.103Z" },
+    { url = "https://files.pythonhosted.org/packages/59/0c/bfed7f30662fcf12206481c2aac57dedee43fe1c49275e85b3a1e1742294/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:157826e2fa245d2ef46c83ea8a5faf77ca19355d278d425c29fda0beb3318037", size = 1634924, upload-time = "2026-03-31T22:00:02.116Z" },
+    { url = "https://files.pythonhosted.org/packages/17/d6/fd518d668a09fd5a3319ae5e984d4d80b9a4b3df4e21c52f02251ef5a32e/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a8aca50daa9493e9e13c0f566201a9006f080e7c50e5e90d0b06f53146a54500", size = 1836119, upload-time = "2026-03-31T22:00:04.756Z" },
+    { url = "https://files.pythonhosted.org/packages/78/b7/15fb7a9d52e112a25b621c67b69c167805cb1f2ab8f1708a5c490d1b52fe/aiohttp-3.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3b13560160d07e047a93f23aaa30718606493036253d5430887514715b67c9d9", size = 1772072, upload-time = "2026-03-31T22:00:07.494Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/df/57ba7f0c4a553fc2bd8b6321df236870ec6fd64a2a473a8a13d4f733214e/aiohttp-3.13.5-cp314-cp314t-win32.whl", hash = "sha256:9a0f4474b6ea6818b41f82172d799e4b3d29e22c2c520ce4357856fced9af2f8", size = 471819, upload-time = "2026-03-31T22:00:10.277Z" },
+    { url = "https://files.pythonhosted.org/packages/62/29/2f8418269e46454a26171bfdd6a055d74febf32234e474930f2f60a17145/aiohttp-3.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:18a2f6c1182c51baa1d28d68fea51513cb2a76612f038853c0ad3c145423d3d9", size = 505441, upload-time = "2026-03-31T22:00:12.791Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anthropic"
+version = "0.94.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "docstring-parser" },
+    { name = "httpx" },
+    { name = "jiter" },
+    { name = "pydantic" },
+    { name = "sniffio" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/60/d7/11a649b986da06aaeb81334632f1843d70e3797f54ca4a9c5d604b7987d0/anthropic-0.94.0.tar.gz", hash = "sha256:dde8c57de73538c5136c1bca9b16da92e75446b53a73562cc911574e4934435c", size = 654236, upload-time = "2026-04-10T22:27:59.853Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/ac/7185750e8688f6ff79b0e3d6a61372c88b81ba81fcda8798c70598e18aca/anthropic-0.94.0-py3-none-any.whl", hash = "sha256:42550b401eed8fcd7f6654234560f99c428306301bca726d32bca4bfb6feb748", size = 627519, upload-time = "2026-04-10T22:27:57.541Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "argcomplete"
+version = "3.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/38/61/0b9ae6399dd4a58d8c1b1dc5a27d6f2808023d0b5dd3104bb99f45a33ff6/argcomplete-3.6.3.tar.gz", hash = "sha256:62e8ed4fd6a45864acc8235409461b72c9a28ee785a2011cc5eb78318786c89c", size = 73754, upload-time = "2025-10-20T03:33:34.741Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/74/f5/9373290775639cb67a2fce7f629a1c240dce9f12fe927bc32b2736e16dfc/argcomplete-3.6.3-py3-none-any.whl", hash = "sha256:f5007b3a600ccac5d25bbce33089211dfd49eab4a7718da3f10e3082525a92ce", size = 43846, upload-time = "2025-10-20T03:33:33.021Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "authlib"
+version = "1.6.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cryptography" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/af/98/00d3dd826d46959ad8e32af2dbb2398868fd9fd0683c26e56d0789bd0e68/authlib-1.6.9.tar.gz", hash = "sha256:d8f2421e7e5980cc1ddb4e32d3f5fa659cfaf60d8eaf3281ebed192e4ab74f04", size = 165134, upload-time = "2026-03-02T07:44:01.998Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/23/b65f568ed0c22f1efacb744d2db1a33c8068f384b8c9b482b52ebdbc3ef6/authlib-1.6.9-py2.py3-none-any.whl", hash = "sha256:f08b4c14e08f0861dc18a32357b33fbcfd2ea86cfe3fe149484b4d764c4a0ac3", size = 244197, upload-time = "2026-03-02T07:44:00.307Z" },
+]
+
+[[package]]
+name = "beartype"
+version = "0.22.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/94/1009e248bbfbab11397abca7193bea6626806be9a327d399810d523a07cb/beartype-0.22.9.tar.gz", hash = "sha256:8f82b54aa723a2848a56008d18875f91c1db02c32ef6a62319a002e3e25a975f", size = 1608866, upload-time = "2025-12-13T06:50:30.72Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/cc/18245721fa7747065ab478316c7fea7c74777d07f37ae60db2e84f8172e8/beartype-0.22.9-py3-none-any.whl", hash = "sha256:d16c9bbc61ea14637596c5f6fbff2ee99cbe3573e46a716401734ef50c3060c2", size = 1333658, upload-time = "2025-12-13T06:50:28.266Z" },
+]
+
+[[package]]
+name = "boto3"
+version = "1.42.88"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+    { name = "jmespath" },
+    { name = "s3transfer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/bb/7d4435cca6fccf235dd40c891c731bcb9078e815917b57ebadd1e0ffabaf/boto3-1.42.88.tar.gz", hash = "sha256:2d22c70de5726918676a06f1a03acfb4d5d9ea92fc759354800b67b22aaeef19", size = 113238, upload-time = "2026-04-10T19:41:06.912Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/2b/8bfddb39a19f5fbc16a869f1a394771e6223f07160dbc0ff6b38e05ea0ae/boto3-1.42.88-py3-none-any.whl", hash = "sha256:2d0f52c971503377e4370d2a83edee6f077ddb8e684366ff38df4f13581d9cfc", size = 140557, upload-time = "2026-04-10T19:41:05.309Z" },
+]
+
+[[package]]
+name = "botocore"
+version = "1.42.88"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jmespath" },
+    { name = "python-dateutil" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/93/50/87966238f7aa3f7e5f87081185d5a407a95ede8b551e11bbe134ca3306dc/botocore-1.42.88.tar.gz", hash = "sha256:cbb59ee464662039b0c2c95a520cdf85b1e8ce00b72375ab9cd9f842cc001301", size = 15195331, upload-time = "2026-04-10T19:40:57.012Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/46/ad14e41245adb8b0c83663ba13e822b68a0df08999dd250e75b0750fdf6c/botocore-1.42.88-py3-none-any.whl", hash = "sha256:032375b213305b6b81eedb269eaeefdf96f674620799bbf96117dca86052cc1a", size = 14876640, upload-time = "2026-04-10T19:40:53.663Z" },
+]
+
+[[package]]
+name = "cachetools"
+version = "7.0.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/dd/57fe3fdb6e65b25a5987fd2cdc7e22db0aef508b91634d2e57d22928d41b/cachetools-7.0.5.tar.gz", hash = "sha256:0cd042c24377200c1dcd225f8b7b12b0ca53cc2c961b43757e774ebe190fd990", size = 37367, upload-time = "2026-03-09T20:51:29.451Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/f3/39cf3367b8107baa44f861dc802cbf16263c945b62d8265d36034fc07bea/cachetools-7.0.5-py3-none-any.whl", hash = "sha256:46bc8ebefbe485407621d0a4264b23c080cedd913921bad7ac3ed2f26c183114", size = 13918, upload-time = "2026-03-09T20:51:27.33Z" },
+]
+
+[[package]]
+name = "caio"
+version = "0.9.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/92/88/b8527e1b00c1811db339a1df8bd1ae49d146fcea9d6a5c40e3a80aaeb38d/caio-0.9.25.tar.gz", hash = "sha256:16498e7f81d1d0f5a4c0ad3f2540e65fe25691376e0a5bd367f558067113ed10", size = 26781, upload-time = "2025-12-26T15:21:36.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/25/79c98ebe12df31548ba4eaf44db11b7cad6b3e7b4203718335620939083c/caio-0.9.25-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fb7ff95af4c31ad3f03179149aab61097a71fd85e05f89b4786de0359dffd044", size = 36983, upload-time = "2025-12-26T15:21:36.075Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/2b/21288691f16d479945968a0a4f2856818c1c5be56881d51d4dac9b255d26/caio-0.9.25-cp312-cp312-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:97084e4e30dfa598449d874c4d8e0c8d5ea17d2f752ef5e48e150ff9d240cd64", size = 82012, upload-time = "2025-12-26T15:22:20.983Z" },
+    { url = "https://files.pythonhosted.org/packages/03/c4/8a1b580875303500a9c12b9e0af58cb82e47f5bcf888c2457742a138273c/caio-0.9.25-cp312-cp312-manylinux_2_34_aarch64.whl", hash = "sha256:4fa69eba47e0f041b9d4f336e2ad40740681c43e686b18b191b6c5f4c5544bfb", size = 81502, upload-time = "2026-03-04T22:08:22.381Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/1c/0fe770b8ffc8362c48134d1592d653a81a3d8748d764bec33864db36319d/caio-0.9.25-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:6bebf6f079f1341d19f7386db9b8b1f07e8cc15ae13bfdaff573371ba0575d69", size = 80200, upload-time = "2026-03-04T22:08:23.382Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/5e6ff127e6f62c9f15d989560435c642144aa4210882f9494204bc892305/caio-0.9.25-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d6c2a3411af97762a2b03840c3cec2f7f728921ff8adda53d7ea2315a8563451", size = 36979, upload-time = "2025-12-26T15:21:35.484Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/9f/f21af50e72117eb528c422d4276cbac11fb941b1b812b182e0a9c70d19c5/caio-0.9.25-cp313-cp313-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0998210a4d5cd5cb565b32ccfe4e53d67303f868a76f212e002a8554692870e6", size = 81900, upload-time = "2025-12-26T15:22:21.919Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/12/c39ae2a4037cb10ad5eb3578eb4d5f8c1a2575c62bba675f3406b7ef0824/caio-0.9.25-cp313-cp313-manylinux_2_34_aarch64.whl", hash = "sha256:1a177d4777141b96f175fe2c37a3d96dec7911ed9ad5f02bac38aaa1c936611f", size = 81523, upload-time = "2026-03-04T22:08:25.187Z" },
+    { url = "https://files.pythonhosted.org/packages/22/59/f8f2e950eb4f1a5a3883e198dca514b9d475415cb6cd7b78b9213a0dd45a/caio-0.9.25-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:9ed3cfb28c0e99fec5e208c934e5c157d0866aa9c32aa4dc5e9b6034af6286b7", size = 80243, upload-time = "2026-03-04T22:08:26.449Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ca/a08fdc7efdcc24e6a6131a93c85be1f204d41c58f474c42b0670af8c016b/caio-0.9.25-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fab6078b9348e883c80a5e14b382e6ad6aabbc4429ca034e76e730cf464269db", size = 36978, upload-time = "2025-12-26T15:21:41.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/6c/d4d24f65e690213c097174d26eda6831f45f4734d9d036d81790a27e7b78/caio-0.9.25-cp314-cp314-manylinux2010_x86_64.manylinux2014_x86_64.manylinux_2_12_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:44a6b58e52d488c75cfaa5ecaa404b2b41cc965e6c417e03251e868ecd5b6d77", size = 81832, upload-time = "2025-12-26T15:22:22.757Z" },
+    { url = "https://files.pythonhosted.org/packages/87/a4/e534cf7d2d0e8d880e25dd61e8d921ffcfe15bd696734589826f5a2df727/caio-0.9.25-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:628a630eb7fb22381dd8e3c8ab7f59e854b9c806639811fc3f4310c6bd711d79", size = 81565, upload-time = "2026-03-04T22:08:27.483Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ed/bf81aeac1d290017e5e5ac3e880fd56ee15e50a6d0353986799d1bc5cfd5/caio-0.9.25-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:0ba16aa605ccb174665357fc729cf500679c2d94d5f1458a6f0d5ca48f2060a7", size = 80071, upload-time = "2026-03-04T22:08:28.751Z" },
+    { url = "https://files.pythonhosted.org/packages/86/93/1f76c8d1bafe3b0614e06b2195784a3765bbf7b0a067661af9e2dd47fc33/caio-0.9.25-py3-none-any.whl", hash = "sha256:06c0bb02d6b929119b1cfbe1ca403c768b2013a369e2db46bfa2a5761cf82e40", size = 19087, upload-time = "2025-12-26T15:22:00.221Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" },
+    { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" },
+    { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" },
+    { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" },
+    { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" },
+    { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" },
+    { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" },
+    { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" },
+    { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" },
+    { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" },
+    { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" },
+    { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" },
+    { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" },
+    { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/75/31212c6bf2503fdf920d87fee5d7a86a2e3bcf444984126f13d8e4016804/click-8.3.2.tar.gz", hash = "sha256:14162b8b3b3550a7d479eafa77dfd3c38d9dc8951f6f69c78913a8f9a7540fd5", size = 302856, upload-time = "2026-04-03T19:14:45.118Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/20/71885d8b97d4f3dde17b1fdb92dbd4908b00541c5a3379787137285f602e/click-8.3.2-py3-none-any.whl", hash = "sha256:1924d2c27c5653561cd2cae4548d1406039cb79b858b747cfea24924bbc1616d", size = 108379, upload-time = "2026-04-03T19:14:43.505Z" },
+]
+
+[[package]]
+name = "cohere"
+version = "6.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastavro" },
+    { name = "httpx" },
+    { name = "pydantic" },
+    { name = "pydantic-core" },
+    { name = "requests" },
+    { name = "tokenizers" },
+    { name = "types-requests" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/67/7aff8a870889ee931aa19e1deb138691e3cc909ee61e1daea86f3475a818/cohere-6.1.0.tar.gz", hash = "sha256:6a52bb459b71b5e79735412ee1a8e87028c5b3afba050c39815fe03c083249b3", size = 207302, upload-time = "2026-04-10T19:44:43.103Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/b4/00c2f9f8387a2e77faf8410210466c46d55dd30a0388de41c54441b148fb/cohere-6.1.0-py3-none-any.whl", hash = "sha256:ad286b3af2583c75ba93624e6f680603d3578a3d73704f997430260b87537ac7", size = 350543, upload-time = "2026-04-10T19:44:41.805Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "46.0.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/47/93/ac8f3d5ff04d54bc814e961a43ae5b0b146154c89c61b47bb07557679b18/cryptography-46.0.7.tar.gz", hash = "sha256:e4cfd68c5f3e0bfdad0d38e023239b96a2fe84146481852dffbcca442c245aa5", size = 750652, upload-time = "2026-04-08T01:57:54.692Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/5d/4a8f770695d73be252331e60e526291e3df0c9b27556a90a6b47bccca4c2/cryptography-46.0.7-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:ea42cbe97209df307fdc3b155f1b6fa2577c0defa8f1f7d3be7d31d189108ad4", size = 7179869, upload-time = "2026-04-08T01:56:17.157Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/45/6d80dc379b0bbc1f9d1e429f42e4cb9e1d319c7a8201beffd967c516ea01/cryptography-46.0.7-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b36a4695e29fe69215d75960b22577197aca3f7a25b9cf9d165dcfe9d80bc325", size = 4275492, upload-time = "2026-04-08T01:56:19.36Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/9a/1765afe9f572e239c3469f2cb429f3ba7b31878c893b246b4b2994ffe2fe/cryptography-46.0.7-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5ad9ef796328c5e3c4ceed237a183f5d41d21150f972455a9d926593a1dcb308", size = 4426670, upload-time = "2026-04-08T01:56:21.415Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/3e/af9246aaf23cd4ee060699adab1e47ced3f5f7e7a8ffdd339f817b446462/cryptography-46.0.7-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:73510b83623e080a2c35c62c15298096e2a5dc8d51c3b4e1740211839d0dea77", size = 4280275, upload-time = "2026-04-08T01:56:23.539Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/54/6bbbfc5efe86f9d71041827b793c24811a017c6ac0fd12883e4caa86b8ed/cryptography-46.0.7-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:cbd5fb06b62bd0721e1170273d3f4d5a277044c47ca27ee257025146c34cbdd1", size = 4928402, upload-time = "2026-04-08T01:56:25.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/cf/054b9d8220f81509939599c8bdbc0c408dbd2bdd41688616a20731371fe0/cryptography-46.0.7-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:420b1e4109cc95f0e5700eed79908cef9268265c773d3a66f7af1eef53d409ef", size = 4459985, upload-time = "2026-04-08T01:56:27.309Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/46/4e4e9c6040fb01c7467d47217d2f882daddeb8828f7df800cb806d8a2288/cryptography-46.0.7-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:24402210aa54baae71d99441d15bb5a1919c195398a87b563df84468160a65de", size = 3990652, upload-time = "2026-04-08T01:56:29.095Z" },
+    { url = "https://files.pythonhosted.org/packages/36/5f/313586c3be5a2fbe87e4c9a254207b860155a8e1f3cca99f9910008e7d08/cryptography-46.0.7-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:8a469028a86f12eb7d2fe97162d0634026d92a21f3ae0ac87ed1c4a447886c83", size = 4279805, upload-time = "2026-04-08T01:56:30.928Z" },
+    { url = "https://files.pythonhosted.org/packages/69/33/60dfc4595f334a2082749673386a4d05e4f0cf4df8248e63b2c3437585f2/cryptography-46.0.7-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:9694078c5d44c157ef3162e3bf3946510b857df5a3955458381d1c7cfc143ddb", size = 4892883, upload-time = "2026-04-08T01:56:32.614Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/0b/333ddab4270c4f5b972f980adef4faa66951a4aaf646ca067af597f15563/cryptography-46.0.7-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:42a1e5f98abb6391717978baf9f90dc28a743b7d9be7f0751a6f56a75d14065b", size = 4459756, upload-time = "2026-04-08T01:56:34.306Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/14/633913398b43b75f1234834170947957c6b623d1701ffc7a9600da907e89/cryptography-46.0.7-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:91bbcb08347344f810cbe49065914fe048949648f6bd5c2519f34619142bbe85", size = 4410244, upload-time = "2026-04-08T01:56:35.977Z" },
+    { url = "https://files.pythonhosted.org/packages/10/f2/19ceb3b3dc14009373432af0c13f46aa08e3ce334ec6eff13492e1812ccd/cryptography-46.0.7-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5d1c02a14ceb9148cc7816249f64f623fbfee39e8c03b3650d842ad3f34d637e", size = 4674868, upload-time = "2026-04-08T01:56:38.034Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/bb/a5c213c19ee94b15dfccc48f363738633a493812687f5567addbcbba9f6f/cryptography-46.0.7-cp311-abi3-win32.whl", hash = "sha256:d23c8ca48e44ee015cd0a54aeccdf9f09004eba9fc96f38c911011d9ff1bd457", size = 3026504, upload-time = "2026-04-08T01:56:39.666Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/02/7788f9fefa1d060ca68717c3901ae7fffa21ee087a90b7f23c7a603c32ae/cryptography-46.0.7-cp311-abi3-win_amd64.whl", hash = "sha256:397655da831414d165029da9bc483bed2fe0e75dde6a1523ec2fe63f3c46046b", size = 3488363, upload-time = "2026-04-08T01:56:41.893Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/56/15619b210e689c5403bb0540e4cb7dbf11a6bf42e483b7644e471a2812b3/cryptography-46.0.7-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:d151173275e1728cf7839aaa80c34fe550c04ddb27b34f48c232193df8db5842", size = 7119671, upload-time = "2026-04-08T01:56:44Z" },
+    { url = "https://files.pythonhosted.org/packages/74/66/e3ce040721b0b5599e175ba91ab08884c75928fbeb74597dd10ef13505d2/cryptography-46.0.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:db0f493b9181c7820c8134437eb8b0b4792085d37dbb24da050476ccb664e59c", size = 4268551, upload-time = "2026-04-08T01:56:46.071Z" },
+    { url = "https://files.pythonhosted.org/packages/03/11/5e395f961d6868269835dee1bafec6a1ac176505a167f68b7d8818431068/cryptography-46.0.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ebd6daf519b9f189f85c479427bbd6e9c9037862cf8fe89ee35503bd209ed902", size = 4408887, upload-time = "2026-04-08T01:56:47.718Z" },
+    { url = "https://files.pythonhosted.org/packages/40/53/8ed1cf4c3b9c8e611e7122fb56f1c32d09e1fff0f1d77e78d9ff7c82653e/cryptography-46.0.7-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:b7b412817be92117ec5ed95f880defe9cf18a832e8cafacf0a22337dc1981b4d", size = 4271354, upload-time = "2026-04-08T01:56:49.312Z" },
+    { url = "https://files.pythonhosted.org/packages/50/46/cf71e26025c2e767c5609162c866a78e8a2915bbcfa408b7ca495c6140c4/cryptography-46.0.7-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:fbfd0e5f273877695cb93baf14b185f4878128b250cc9f8e617ea0c025dfb022", size = 4905845, upload-time = "2026-04-08T01:56:50.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ea/01276740375bac6249d0a971ebdf6b4dc9ead0ee0a34ef3b5a88c1a9b0d4/cryptography-46.0.7-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:ffca7aa1d00cf7d6469b988c581598f2259e46215e0140af408966a24cf086ce", size = 4444641, upload-time = "2026-04-08T01:56:52.882Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/4c/7d258f169ae71230f25d9f3d06caabcff8c3baf0978e2b7d65e0acac3827/cryptography-46.0.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:60627cf07e0d9274338521205899337c5d18249db56865f943cbe753aa96f40f", size = 3967749, upload-time = "2026-04-08T01:56:54.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2a/2ea0767cad19e71b3530e4cad9605d0b5e338b6a1e72c37c9c1ceb86c333/cryptography-46.0.7-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:80406c3065e2c55d7f49a9550fe0c49b3f12e5bfff5dedb727e319e1afb9bf99", size = 4270942, upload-time = "2026-04-08T01:56:56.416Z" },
+    { url = "https://files.pythonhosted.org/packages/41/3d/fe14df95a83319af25717677e956567a105bb6ab25641acaa093db79975d/cryptography-46.0.7-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:c5b1ccd1239f48b7151a65bc6dd54bcfcc15e028c8ac126d3fada09db0e07ef1", size = 4871079, upload-time = "2026-04-08T01:56:58.31Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/4a479e0f36f8f378d397f4eab4c850b4ffb79a2f0d58704b8fa0703ddc11/cryptography-46.0.7-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:d5f7520159cd9c2154eb61eb67548ca05c5774d39e9c2c4339fd793fe7d097b2", size = 4443999, upload-time = "2026-04-08T01:57:00.508Z" },
+    { url = "https://files.pythonhosted.org/packages/28/17/b59a741645822ec6d04732b43c5d35e4ef58be7bfa84a81e5ae6f05a1d33/cryptography-46.0.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fcd8eac50d9138c1d7fc53a653ba60a2bee81a505f9f8850b6b2888555a45d0e", size = 4399191, upload-time = "2026-04-08T01:57:02.654Z" },
+    { url = "https://files.pythonhosted.org/packages/59/6a/bb2e166d6d0e0955f1e9ff70f10ec4b2824c9cfcdb4da772c7dd69cc7d80/cryptography-46.0.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65814c60f8cc400c63131584e3e1fad01235edba2614b61fbfbfa954082db0ee", size = 4655782, upload-time = "2026-04-08T01:57:04.592Z" },
+    { url = "https://files.pythonhosted.org/packages/95/b6/3da51d48415bcb63b00dc17c2eff3a651b7c4fed484308d0f19b30e8cb2c/cryptography-46.0.7-cp314-cp314t-win32.whl", hash = "sha256:fdd1736fed309b4300346f88f74cd120c27c56852c3838cab416e7a166f67298", size = 3002227, upload-time = "2026-04-08T01:57:06.91Z" },
+    { url = "https://files.pythonhosted.org/packages/32/a8/9f0e4ed57ec9cebe506e58db11ae472972ecb0c659e4d52bbaee80ca340a/cryptography-46.0.7-cp314-cp314t-win_amd64.whl", hash = "sha256:e06acf3c99be55aa3b516397fe42f5855597f430add9c17fa46bf2e0fb34c9bb", size = 3475332, upload-time = "2026-04-08T01:57:08.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/7f/cd42fc3614386bc0c12f0cb3c4ae1fc2bbca5c9662dfed031514911d513d/cryptography-46.0.7-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:462ad5cb1c148a22b2e3bcc5ad52504dff325d17daf5df8d88c17dda1f75f2a4", size = 7165618, upload-time = "2026-04-08T01:57:10.645Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/d0/36a49f0262d2319139d2829f773f1b97ef8aef7f97e6e5bd21455e5a8fb5/cryptography-46.0.7-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:84d4cced91f0f159a7ddacad249cc077e63195c36aac40b4150e7a57e84fffe7", size = 4270628, upload-time = "2026-04-08T01:57:12.885Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/6c/1a42450f464dda6ffbe578a911f773e54dd48c10f9895a23a7e88b3e7db5/cryptography-46.0.7-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:128c5edfe5e5938b86b03941e94fac9ee793a94452ad1365c9fc3f4f62216832", size = 4415405, upload-time = "2026-04-08T01:57:14.923Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/92/4ed714dbe93a066dc1f4b4581a464d2d7dbec9046f7c8b7016f5286329e2/cryptography-46.0.7-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:5e51be372b26ef4ba3de3c167cd3d1022934bc838ae9eaad7e644986d2a3d163", size = 4272715, upload-time = "2026-04-08T01:57:16.638Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/e6/a26b84096eddd51494bba19111f8fffe976f6a09f132706f8f1bf03f51f7/cryptography-46.0.7-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:cdf1a610ef82abb396451862739e3fc93b071c844399e15b90726ef7470eeaf2", size = 4918400, upload-time = "2026-04-08T01:57:19.021Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/08/ffd537b605568a148543ac3c2b239708ae0bd635064bab41359252ef88ed/cryptography-46.0.7-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1d25aee46d0c6f1a501adcddb2d2fee4b979381346a78558ed13e50aa8a59067", size = 4450634, upload-time = "2026-04-08T01:57:21.185Z" },
+    { url = "https://files.pythonhosted.org/packages/16/01/0cd51dd86ab5b9befe0d031e276510491976c3a80e9f6e31810cce46c4ad/cryptography-46.0.7-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:cdfbe22376065ffcf8be74dc9a909f032df19bc58a699456a21712d6e5eabfd0", size = 3985233, upload-time = "2026-04-08T01:57:22.862Z" },
+    { url = "https://files.pythonhosted.org/packages/92/49/819d6ed3a7d9349c2939f81b500a738cb733ab62fbecdbc1e38e83d45e12/cryptography-46.0.7-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:abad9dac36cbf55de6eb49badd4016806b3165d396f64925bf2999bcb67837ba", size = 4271955, upload-time = "2026-04-08T01:57:24.814Z" },
+    { url = "https://files.pythonhosted.org/packages/80/07/ad9b3c56ebb95ed2473d46df0847357e01583f4c52a85754d1a55e29e4d0/cryptography-46.0.7-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:935ce7e3cfdb53e3536119a542b839bb94ec1ad081013e9ab9b7cfd478b05006", size = 4879888, upload-time = "2026-04-08T01:57:26.88Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/c7/201d3d58f30c4c2bdbe9b03844c291feb77c20511cc3586daf7edc12a47b/cryptography-46.0.7-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:35719dc79d4730d30f1c2b6474bd6acda36ae2dfae1e3c16f2051f215df33ce0", size = 4449961, upload-time = "2026-04-08T01:57:29.068Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/ef/649750cbf96f3033c3c976e112265c33906f8e462291a33d77f90356548c/cryptography-46.0.7-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7bbc6ccf49d05ac8f7d7b5e2e2c33830d4fe2061def88210a126d130d7f71a85", size = 4401696, upload-time = "2026-04-08T01:57:31.029Z" },
+    { url = "https://files.pythonhosted.org/packages/41/52/a8908dcb1a389a459a29008c29966c1d552588d4ae6d43f3a1a4512e0ebe/cryptography-46.0.7-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a1529d614f44b863a7b480c6d000fe93b59acee9c82ffa027cfadc77521a9f5e", size = 4664256, upload-time = "2026-04-08T01:57:33.144Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/fa/f0ab06238e899cc3fb332623f337a7364f36f4bb3f2534c2bb95a35b132c/cryptography-46.0.7-cp38-abi3-win32.whl", hash = "sha256:f247c8c1a1fb45e12586afbb436ef21ff1e80670b2861a90353d9b025583d246", size = 3013001, upload-time = "2026-04-08T01:57:34.933Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/f1/00ce3bde3ca542d1acd8f8cfa38e446840945aa6363f9b74746394b14127/cryptography-46.0.7-cp38-abi3-win_amd64.whl", hash = "sha256:506c4ff91eff4f82bdac7633318a526b1d1309fc07ca76a3ad182cb5b686d6d3", size = 3472985, upload-time = "2026-04-08T01:57:36.714Z" },
+]
+
+[[package]]
+name = "cyclopts"
+version = "4.10.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "docstring-parser" },
+    { name = "rich" },
+    { name = "rich-rst" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/2c/fced34890f6e5a93a4b7afb2c71e8eee2a0719fb26193a0abf159ecb714d/cyclopts-4.10.2.tar.gz", hash = "sha256:d7b950457ef2563596d56331f80cbbbf86a2772535fb8b315c4f03bc7e6127f1", size = 166664, upload-time = "2026-04-08T23:57:45.805Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/bd/05055d8360cef0757d79367157f3b15c0a0715e81e08f86a04018ec045f0/cyclopts-4.10.2-py3-none-any.whl", hash = "sha256:a1f2d6f8f7afac9456b48f75a40b36658778ddc9c6d406b520d017ae32c990fe", size = 204314, upload-time = "2026-04-08T23:57:46.969Z" },
+]
+
+[[package]]
+name = "distro"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
+]
+
+[[package]]
+name = "dnspython"
+version = "2.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" },
+]
+
+[[package]]
+name = "docstring-parser"
+version = "0.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442, upload-time = "2025-07-21T07:35:01.868Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896, upload-time = "2025-07-21T07:35:00.684Z" },
+]
+
+[[package]]
+name = "docutils"
+version = "0.22.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/b6/03bb70946330e88ffec97aefd3ea75ba575cb2e762061e0e62a213befee8/docutils-0.22.4.tar.gz", hash = "sha256:4db53b1fde9abecbb74d91230d32ab626d94f6badfc575d6db9194a49df29968", size = 2291750, upload-time = "2025-12-18T19:00:26.443Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/10/5da547df7a391dcde17f59520a231527b8571e6f46fc8efb02ccb370ab12/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de", size = 633196, upload-time = "2025-12-18T19:00:18.077Z" },
+]
+
+[[package]]
+name = "email-validator"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "dnspython" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/22/900cb125c76b7aaa450ce02fd727f452243f2e91a61af068b40adba60ea9/email_validator-2.3.0.tar.gz", hash = "sha256:9fc05c37f2f6cf439ff414f8fc46d917929974a82244c20eb10231ba60c54426", size = 51238, upload-time = "2025-08-26T13:09:06.831Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/15/545e2b6cf2e3be84bc1ed85613edd75b8aea69807a71c26f4ca6a9258e82/email_validator-2.3.0-py3-none-any.whl", hash = "sha256:80f13f623413e6b197ae73bb10bf4eb0908faf509ad8362c5edeb0be7fd450b4", size = 35604, upload-time = "2025-08-26T13:09:05.858Z" },
+]
+
+[[package]]
+name = "eval-type-backport"
+version = "0.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fb/a3/cafafb4558fd638aadfe4121dc6cefb8d743368c085acb2f521df0f3d9d7/eval_type_backport-0.3.1.tar.gz", hash = "sha256:57e993f7b5b69d271e37482e62f74e76a0276c82490cf8e4f0dffeb6b332d5ed", size = 9445, upload-time = "2025-12-02T11:51:42.987Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/22/fdc2e30d43ff853720042fa15baa3e6122722be1a7950a98233ebb55cd71/eval_type_backport-0.3.1-py3-none-any.whl", hash = "sha256:279ab641905e9f11129f56a8a78f493518515b83402b860f6f06dd7c011fdfa8", size = 6063, upload-time = "2025-12-02T11:51:41.665Z" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
+]
+
+[[package]]
+name = "executing"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.135.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f7/e6/7adb4c5fa231e82c35b8f5741a9f2d055f520c29af5546fd70d3e8e1cd2e/fastapi-0.135.3.tar.gz", hash = "sha256:bd6d7caf1a2bdd8d676843cdcd2287729572a1ef524fc4d65c17ae002a1be654", size = 396524, upload-time = "2026-04-01T16:23:58.188Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/a4/5caa2de7f917a04ada20018eccf60d6cc6145b0199d55ca3711b0fc08312/fastapi-0.135.3-py3-none-any.whl", hash = "sha256:9b0f590c813acd13d0ab43dd8494138eb58e484bfac405db1f3187cfc5810d98", size = 117734, upload-time = "2026-04-01T16:23:59.328Z" },
+]
+
+[[package]]
+name = "fastavro"
+version = "1.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/8b/fa2d3287fd2267be6261d0177c6809a7fa12c5600ddb33490c8dc29e77b2/fastavro-1.12.1.tar.gz", hash = "sha256:2f285be49e45bc047ab2f6bed040bb349da85db3f3c87880e4b92595ea093b2b", size = 1025661, upload-time = "2025-10-10T15:40:55.41Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/f0/10bd1a3d08667fa0739e2b451fe90e06df575ec8b8ba5d3135c70555c9bd/fastavro-1.12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:509818cb24b98a804fc80be9c5fed90f660310ae3d59382fc811bfa187122167", size = 1009057, upload-time = "2025-10-10T15:41:24.556Z" },
+    { url = "https://files.pythonhosted.org/packages/78/ad/0d985bc99e1fa9e74c636658000ba38a5cd7f5ab2708e9c62eaf736ecf1a/fastavro-1.12.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:089e155c0c76e0d418d7e79144ce000524dd345eab3bc1e9c5ae69d500f71b14", size = 3391866, upload-time = "2025-10-10T15:41:26.882Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/9e/b4951dc84ebc34aac69afcbfbb22ea4a91080422ec2bfd2c06076ff1d419/fastavro-1.12.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44cbff7518901c91a82aab476fcab13d102e4999499df219d481b9e15f61af34", size = 3458005, upload-time = "2025-10-10T15:41:29.017Z" },
+    { url = "https://files.pythonhosted.org/packages/af/f8/5a8df450a9f55ca8441f22ea0351d8c77809fc121498b6970daaaf667a21/fastavro-1.12.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a275e48df0b1701bb764b18a8a21900b24cf882263cb03d35ecdba636bbc830b", size = 3295258, upload-time = "2025-10-10T15:41:31.564Z" },
+    { url = "https://files.pythonhosted.org/packages/99/b2/40f25299111d737e58b85696e91138a66c25b7334f5357e7ac2b0e8966f8/fastavro-1.12.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2de72d786eb38be6b16d556b27232b1bf1b2797ea09599507938cdb7a9fe3e7c", size = 3430328, upload-time = "2025-10-10T15:41:33.689Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/07/85157a7c57c5f8b95507d7829b5946561e5ee656ff80e9dd9a757f53ddaf/fastavro-1.12.1-cp312-cp312-win_amd64.whl", hash = "sha256:9090f0dee63fe022ee9cc5147483366cc4171c821644c22da020d6b48f576b4f", size = 444140, upload-time = "2025-10-10T15:41:34.902Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/57/26d5efef9182392d5ac9f253953c856ccb66e4c549fd3176a1e94efb05c9/fastavro-1.12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:78df838351e4dff9edd10a1c41d1324131ffecbadefb9c297d612ef5363c049a", size = 1000599, upload-time = "2025-10-10T15:41:36.554Z" },
+    { url = "https://files.pythonhosted.org/packages/33/cb/8ab55b21d018178eb126007a56bde14fd01c0afc11d20b5f2624fe01e698/fastavro-1.12.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:780476c23175d2ae457c52f45b9ffa9d504593499a36cd3c1929662bf5b7b14b", size = 3335933, upload-time = "2025-10-10T15:41:39.07Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/03/9c94ec9bf873eb1ffb0aa694f4e71940154e6e9728ddfdc46046d7e8ced4/fastavro-1.12.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0714b285160fcd515eb0455540f40dd6dac93bdeacdb03f24e8eac3d8aa51f8d", size = 3402066, upload-time = "2025-10-10T15:41:41.608Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c8/cb472347c5a584ccb8777a649ebb28278fccea39d005fc7df19996f41df8/fastavro-1.12.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a8bc2dcec5843d499f2489bfe0747999108f78c5b29295d877379f1972a3d41a", size = 3240038, upload-time = "2025-10-10T15:41:43.743Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/77/569ce9474c40304b3a09e109494e020462b83e405545b78069ddba5f614e/fastavro-1.12.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3b1921ac35f3d89090a5816b626cf46e67dbecf3f054131f84d56b4e70496f45", size = 3369398, upload-time = "2025-10-10T15:41:45.719Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/1f/9589e35e9ea68035385db7bdbf500d36b8891db474063fb1ccc8215ee37c/fastavro-1.12.1-cp313-cp313-win_amd64.whl", hash = "sha256:5aa777b8ee595b50aa084104cd70670bf25a7bbb9fd8bb5d07524b0785ee1699", size = 444220, upload-time = "2025-10-10T15:41:47.39Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/d2/78435fe737df94bd8db2234b2100f5453737cffd29adee2504a2b013de84/fastavro-1.12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c3d67c47f177e486640404a56f2f50b165fe892cc343ac3a34673b80cc7f1dd6", size = 1086611, upload-time = "2025-10-10T15:41:48.818Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/be/428f99b10157230ddac77ec8cc167005b29e2bd5cbe228345192bb645f30/fastavro-1.12.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5217f773492bac43dae15ff2931432bce2d7a80be7039685a78d3fab7df910bd", size = 3541001, upload-time = "2025-10-10T15:41:50.871Z" },
+    { url = "https://files.pythonhosted.org/packages/16/08/a2eea4f20b85897740efe44887e1ac08f30dfa4bfc3de8962bdcbb21a5a1/fastavro-1.12.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:469fecb25cba07f2e1bfa4c8d008477cd6b5b34a59d48715e1b1a73f6160097d", size = 3432217, upload-time = "2025-10-10T15:41:53.149Z" },
+    { url = "https://files.pythonhosted.org/packages/87/bb/b4c620b9eb6e9838c7f7e4b7be0762834443adf9daeb252a214e9ad3178c/fastavro-1.12.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d71c8aa841ef65cfab709a22bb887955f42934bced3ddb571e98fdbdade4c609", size = 3366742, upload-time = "2025-10-10T15:41:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/d1/e69534ccdd5368350646fea7d93be39e5f77c614cca825c990bd9ca58f67/fastavro-1.12.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b81fc04e85dfccf7c028e0580c606e33aa8472370b767ef058aae2c674a90746", size = 3383743, upload-time = "2025-10-10T15:41:57.68Z" },
+    { url = "https://files.pythonhosted.org/packages/58/54/b7b4a0c3fb5fcba38128542da1b26c4e6d69933c923f493548bdfd63ab6a/fastavro-1.12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9445da127751ba65975d8e4bdabf36bfcfdad70fc35b2d988e3950cce0ec0e7c", size = 1001377, upload-time = "2025-10-10T15:41:59.241Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/4f/0e589089c7df0d8f57d7e5293fdc34efec9a3b758a0d4d0c99a7937e2492/fastavro-1.12.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed924233272719b5d5a6a0b4d80ef3345fc7e84fc7a382b6232192a9112d38a6", size = 3320401, upload-time = "2025-10-10T15:42:01.682Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/19/260110d56194ae29d7e423a336fccea8bcd103196d00f0b364b732bdb84e/fastavro-1.12.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3616e2f0e1c9265e92954fa099db79c6e7817356d3ff34f4bcc92699ae99697c", size = 3350894, upload-time = "2025-10-10T15:42:04.073Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/96/58b0411e8be9694d5972bee3167d6c1fd1fdfdf7ce253c1a19a327208f4f/fastavro-1.12.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:cb0337b42fd3c047fcf0e9b7597bd6ad25868de719f29da81eabb6343f08d399", size = 3229644, upload-time = "2025-10-10T15:42:06.221Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/db/38660660eac82c30471d9101f45b3acfdcbadfe42d8f7cdb129459a45050/fastavro-1.12.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:64961ab15b74b7c168717bbece5660e0f3d457837c3cc9d9145181d011199fa7", size = 3329704, upload-time = "2025-10-10T15:42:08.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/a9/1672910f458ecb30b596c9e59e41b7c00309b602a0494341451e92e62747/fastavro-1.12.1-cp314-cp314-win_amd64.whl", hash = "sha256:792356d320f6e757e89f7ac9c22f481e546c886454a6709247f43c0dd7058004", size = 452911, upload-time = "2025-10-10T15:42:09.795Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/8d/2e15d0938ded1891b33eff252e8500605508b799c2e57188a933f0bd744c/fastavro-1.12.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:120aaf82ac19d60a1016afe410935fe94728752d9c2d684e267e5b7f0e70f6d9", size = 3541999, upload-time = "2025-10-10T15:42:11.794Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/1c/6dfd082a205be4510543221b734b1191299e6a1810c452b6bc76dfa6968e/fastavro-1.12.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6a3462934b20a74f9ece1daa49c2e4e749bd9a35fa2657b53bf62898fba80f5", size = 3433972, upload-time = "2025-10-10T15:42:14.485Z" },
+    { url = "https://files.pythonhosted.org/packages/24/90/9de694625a1a4b727b1ad0958d220cab25a9b6cf7f16a5c7faa9ea7b2261/fastavro-1.12.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1f81011d54dd47b12437b51dd93a70a9aa17b61307abf26542fc3c13efbc6c51", size = 3368752, upload-time = "2025-10-10T15:42:16.618Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/93/b44f67589e4d439913dab6720f7e3507b0fa8b8e56d06f6fc875ced26afb/fastavro-1.12.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:43ded16b3f4a9f1a42f5970c2aa618acb23ea59c4fcaa06680bdf470b255e5a8", size = 3386636, upload-time = "2025-10-10T15:42:18.974Z" },
+]
+
+[[package]]
+name = "fastmcp"
+version = "3.2.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "authlib" },
+    { name = "cyclopts" },
+    { name = "exceptiongroup" },
+    { name = "httpx" },
+    { name = "jsonref" },
+    { name = "jsonschema-path" },
+    { name = "mcp" },
+    { name = "openapi-pydantic" },
+    { name = "opentelemetry-api" },
+    { name = "packaging" },
+    { name = "platformdirs" },
+    { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"] },
+    { name = "pydantic", extra = ["email"] },
+    { name = "pyperclip" },
+    { name = "python-dotenv" },
+    { name = "pyyaml" },
+    { name = "rich" },
+    { name = "uncalled-for" },
+    { name = "uvicorn" },
+    { name = "watchfiles" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b9/42/7eed0a38e3b7a386805fecacf8a5a9353a2b3040395ef9e30e585d8549ac/fastmcp-3.2.3.tar.gz", hash = "sha256:4f02ae8b00227285a0cf6544dea1db29b022c8cdd8d3dfdec7118540210ae60a", size = 26328743, upload-time = "2026-04-09T22:05:03.402Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/48/84b6dcba793178a44b9d99b4def6cd62f870dcfc5bb7b9153ac390135812/fastmcp-3.2.3-py3-none-any.whl", hash = "sha256:cc50af6eed1f62ed8b6ebf4987286d8d1d006f08d5bec739d5c7fb76160e0911", size = 707260, upload-time = "2026-04-09T22:05:01.225Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.25.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+    { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+    { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2026.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/cf/b50ddf667c15276a9ab15a70ef5f257564de271957933ffea49d2cdbcdfb/fsspec-2026.3.0.tar.gz", hash = "sha256:1ee6a0e28677557f8c2f994e3eea77db6392b4de9cd1f5d7a9e87a0ae9d01b41", size = 313547, upload-time = "2026-03-27T19:11:14.892Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d5/1f/5f4a3cd9e4440e9d9bc78ad0a91a1c8d46b4d429d5239ebe6793c9fe5c41/fsspec-2026.3.0-py3-none-any.whl", hash = "sha256:d2ceafaad1b3457968ed14efa28798162f1638dbb5d2a6868a2db002a5ee39a4", size = 202595, upload-time = "2026-03-27T19:11:13.595Z" },
+]
+
+[[package]]
+name = "genai-prices"
+version = "0.0.56"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/44/6b/94b3018a672c7775edfb485f0fed8f6068fba75e49b067e8a1ac5eb96764/genai_prices-0.0.56.tar.gz", hash = "sha256:ac24b16a84d0ab97539bfa48dfa4649689de8e3ce71c12ebacef29efb1998045", size = 65872, upload-time = "2026-03-20T20:33:00.732Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/f6/8ef7e4c286deb2709d11ca96a5237caae3ef4876ab3c48095856cfd2df30/genai_prices-0.0.56-py3-none-any.whl", hash = "sha256:dbe86be8f3f556bed1b72209ed36851fec8b01793b3b220f42921a4e7da945f6", size = 68966, upload-time = "2026-03-20T20:33:02.555Z" },
+]
+
+[[package]]
+name = "google-auth"
+version = "2.49.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cryptography" },
+    { name = "pyasn1-modules" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c6/fc/e925290a1ad95c975c459e2df070fac2b90954e13a0370ac505dff78cb99/google_auth-2.49.2.tar.gz", hash = "sha256:c1ae38500e73065dcae57355adb6278cf8b5c8e391994ae9cbadbcb9631ab409", size = 333958, upload-time = "2026-04-10T00:41:21.888Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/76/d241a5c927433420507215df6cac1b1fa4ac0ba7a794df42a84326c68da8/google_auth-2.49.2-py3-none-any.whl", hash = "sha256:c2720924dfc82dedb962c9f52cabb2ab16714fd0a6a707e40561d217574ed6d5", size = 240638, upload-time = "2026-04-10T00:41:14.501Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "google-genai"
+version = "1.72.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "google-auth", extra = ["requests"] },
+    { name = "httpx" },
+    { name = "pydantic" },
+    { name = "requests" },
+    { name = "sniffio" },
+    { name = "tenacity" },
+    { name = "typing-extensions" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3c/20/2aff5ea3cd7459f85101d119c136d9ca4369fcda3dcf0cfee89b305611a4/google_genai-1.72.0.tar.gz", hash = "sha256:abe7d3aecfafb464b904e3a09c81b626fb425e160e123e71a5125a7021cea7b2", size = 522844, upload-time = "2026-04-09T21:35:46.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/3d/9f70246114cdf56a2615a40428ced08bc844f5a26247fe812b2f0dd4eaca/google_genai-1.72.0-py3-none-any.whl", hash = "sha256:ea861e4c6946e3185c24b40d95503e088fc230a73a71fec0ef78164b369a8489", size = 764230, upload-time = "2026-04-09T21:35:44.587Z" },
+]
+
+[[package]]
+name = "googleapis-common-protos"
+version = "1.74.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/20/18/a746c8344152d368a5aac738d4c857012f2c5d1fd2eac7e17b647a7861bd/googleapis_common_protos-1.74.0.tar.gz", hash = "sha256:57971e4eeeba6aad1163c1f0fc88543f965bb49129b8bb55b2b7b26ecab084f1", size = 151254, upload-time = "2026-04-02T21:23:26.679Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b6/b0/be5d3329badb9230b765de6eea66b73abd5944bdeb5afb3562ddcd80ae84/googleapis_common_protos-1.74.0-py3-none-any.whl", hash = "sha256:702216f78610bb510e3f12ac3cafd281b7ac45cc5d86e90ad87e4d301a3426b5", size = 300743, upload-time = "2026-04-02T21:22:49.108Z" },
+]
+
+[[package]]
+name = "griffelib"
+version = "2.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/82/74f4a3310cdabfbb10da554c3a672847f1ed33c6f61dd472681ce7f1fe67/griffelib-2.0.2.tar.gz", hash = "sha256:3cf20b3bc470e83763ffbf236e0076b1211bac1bc67de13daf494640f2de707e", size = 166461, upload-time = "2026-03-27T11:34:51.091Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/8c/c9138d881c79aa0ea9ed83cbd58d5ca75624378b38cee225dcf5c42cc91f/griffelib-2.0.2-py3-none-any.whl", hash = "sha256:925c857658fb1ba40c0772c37acbc2ab650bd794d9c1b9726922e36ea4117ea1", size = 142357, upload-time = "2026-03-27T11:34:46.275Z" },
+]
+
+[[package]]
+name = "groq"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "httpx" },
+    { name = "pydantic" },
+    { name = "sniffio" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d3/c7/a2153b639062f59f9bc93a1b5507c0c4a6b654b8a9edbf432ec2f4a62d2d/groq-1.1.2.tar.gz", hash = "sha256:9ec2b5b6a1c4856a8c6c38741353c5ab37472a4e3fded02af783750d849cc988", size = 154033, upload-time = "2026-03-25T23:16:10.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/b0/83e3892a4597a4b8ebf8a662aeaf314765c4c2340516eb1d049b459b24fc/groq-1.1.2-py3-none-any.whl", hash = "sha256:348cb7a674b6aa7105719b533f6fc48fd32b503bc9256924aaed6dc186f778b5", size = 141700, upload-time = "2026-03-25T23:16:08.998Z" },
+]
+
+[[package]]
+name = "grpcio"
+version = "1.80.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/e8/a2b749265eb3415abc94f2e619bbd9e9707bebdda787e61c593004ec927a/grpcio-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:c624cc9f1008361014378c9d776de7182b11fe8b2e5a81bc69f23a295f2a1ad0", size = 6015616, upload-time = "2026-03-30T08:47:13.428Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/97/b1282161a15d699d1e90c360df18d19165a045ce1c343c7f313f5e8a0b77/grpcio-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:f49eddcac43c3bf350c0385366a58f36bed8cc2c0ec35ef7b74b49e56552c0c2", size = 12014204, upload-time = "2026-03-30T08:47:15.873Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/5e/d319c6e997b50c155ac5a8cb12f5173d5b42677510e886d250d50264949d/grpcio-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d334591df610ab94714048e0d5b4f3dd5ad1bee74dfec11eee344220077a79de", size = 6563866, upload-time = "2026-03-30T08:47:18.588Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/f6/fdd975a2cb4d78eb67769a7b3b3830970bfa2e919f1decf724ae4445f42c/grpcio-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0cb517eb1d0d0aaf1d87af7cc5b801d686557c1d88b2619f5e31fab3c2315921", size = 7273060, upload-time = "2026-03-30T08:47:21.113Z" },
+    { url = "https://files.pythonhosted.org/packages/db/f0/a3deb5feba60d9538a962913e37bd2e69a195f1c3376a3dd44fe0427e996/grpcio-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4e78c4ac0d97dc2e569b2f4bcbbb447491167cb358d1a389fc4af71ab6f70411", size = 6782121, upload-time = "2026-03-30T08:47:23.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/84/36c6dcfddc093e108141f757c407902a05085e0c328007cb090d56646cdf/grpcio-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2ed770b4c06984f3b47eb0517b1c69ad0b84ef3f40128f51448433be904634cd", size = 7383811, upload-time = "2026-03-30T08:47:26.517Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ef/f3a77e3dc5b471a0ec86c564c98d6adfa3510d38f8ee99010410858d591e/grpcio-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:256507e2f524092f1473071a05e65a5b10d84b82e3ff24c5b571513cfaa61e2f", size = 8393860, upload-time = "2026-03-30T08:47:29.439Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/8d/9d4d27ed7f33d109c50d6b5ce578a9914aa68edab75d65869a17e630a8d1/grpcio-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a6284a5d907c37db53350645567c522be314bac859a64a7a5ca63b77bb7958f", size = 7830132, upload-time = "2026-03-30T08:47:33.254Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e4/9990b41c6d7a44e1e9dee8ac11d7a9802ba1378b40d77468a7761d1ad288/grpcio-1.80.0-cp312-cp312-win32.whl", hash = "sha256:c71309cfce2f22be26aa4a847357c502db6c621f1a49825ae98aa0907595b193", size = 4140904, upload-time = "2026-03-30T08:47:35.319Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/2c/296f6138caca1f4b92a31ace4ae1b87dab692fc16a7a3417af3bb3c805bf/grpcio-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe648599c0e37594c4809d81a9e77bd138cc82eb8baa71b6a86af65426723ff", size = 4880944, upload-time = "2026-03-30T08:47:37.831Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/7c3c25789e3f069e581dc342e03613c5b1cb012c4e8c7d9d5cf960a75856/grpcio-1.80.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:e9e408fc016dffd20661f0126c53d8a31c2821b5c13c5d67a0f5ed5de93319ad", size = 6017243, upload-time = "2026-03-30T08:47:40.075Z" },
+    { url = "https://files.pythonhosted.org/packages/04/19/21a9806eb8240e174fd1ab0cd5b9aa948bb0e05c2f2f55f9d5d7405e6d08/grpcio-1.80.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:92d787312e613754d4d8b9ca6d3297e69994a7912a32fa38c4c4e01c272974b0", size = 12010840, upload-time = "2026-03-30T08:47:43.11Z" },
+    { url = "https://files.pythonhosted.org/packages/18/3a/23347d35f76f639e807fb7a36fad3068aed100996849a33809591f26eca6/grpcio-1.80.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8ac393b58aa16991a2f1144ec578084d544038c12242da3a215966b512904d0f", size = 6567644, upload-time = "2026-03-30T08:47:46.806Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/40/96e07ecb604a6a67ae6ab151e3e35b132875d98bc68ec65f3e5ab3e781d7/grpcio-1.80.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:68e5851ac4b9afe07e7f84483803ad167852570d65326b34d54ca560bfa53fb6", size = 7277830, upload-time = "2026-03-30T08:47:49.643Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/e2/da1506ecea1f34a5e365964644b35edef53803052b763ca214ba3870c856/grpcio-1.80.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:873ff5d17d68992ef6605330127425d2fc4e77e612fa3c3e0ed4e668685e3140", size = 6783216, upload-time = "2026-03-30T08:47:52.817Z" },
+    { url = "https://files.pythonhosted.org/packages/44/83/3b20ff58d0c3b7f6caaa3af9a4174d4023701df40a3f39f7f1c8e7c48f9d/grpcio-1.80.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2bea16af2750fd0a899bf1abd9022244418b55d1f37da2202249ba4ba673838d", size = 7385866, upload-time = "2026-03-30T08:47:55.687Z" },
+    { url = "https://files.pythonhosted.org/packages/47/45/55c507599c5520416de5eefecc927d6a0d7af55e91cfffb2e410607e5744/grpcio-1.80.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba0db34f7e1d803a878284cd70e4c63cb6ae2510ba51937bf8f45ba997cefcf7", size = 8391602, upload-time = "2026-03-30T08:47:58.303Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bb/dd06f4c24c01db9cf11341b547d0a016b2c90ed7dbbb086a5710df7dd1d7/grpcio-1.80.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8eb613f02d34721f1acf3626dfdb3545bd3c8505b0e52bf8b5710a28d02e8aa7", size = 7826752, upload-time = "2026-03-30T08:48:01.311Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/1e/9d67992ba23371fd63d4527096eb8c6b76d74d52b500df992a3343fd7251/grpcio-1.80.0-cp313-cp313-win32.whl", hash = "sha256:93b6f823810720912fd131f561f91f5fed0fda372b6b7028a2681b8194d5d294", size = 4142310, upload-time = "2026-03-30T08:48:04.594Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e6/283326a27da9e2c3038bc93eeea36fb118ce0b2d03922a9cda6688f53c5b/grpcio-1.80.0-cp313-cp313-win_amd64.whl", hash = "sha256:e172cf795a3ba5246d3529e4d34c53db70e888fa582a8ffebd2e6e48bc0cba50", size = 4882833, upload-time = "2026-03-30T08:48:07.363Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/6d/e65307ce20f5a09244ba9e9d8476e99fb039de7154f37fb85f26978b59c3/grpcio-1.80.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:3d4147a97c8344d065d01bbf8b6acec2cf86fb0400d40696c8bdad34a64ffc0e", size = 6017376, upload-time = "2026-03-30T08:48:10.005Z" },
+    { url = "https://files.pythonhosted.org/packages/69/10/9cef5d9650c72625a699c549940f0abb3c4bfdb5ed45a5ce431f92f31806/grpcio-1.80.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8e11f167935b3eb089ac9038e1a063e6d7dbe995c0bb4a661e614583352e76f", size = 12018133, upload-time = "2026-03-30T08:48:12.927Z" },
+    { url = "https://files.pythonhosted.org/packages/04/82/983aabaad82ba26113caceeb9091706a0696b25da004fe3defb5b346e15b/grpcio-1.80.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f14b618fc30de822681ee986cfdcc2d9327229dc4c98aed16896761cacd468b9", size = 6574748, upload-time = "2026-03-30T08:48:16.386Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d7/031666ef155aa0bf399ed7e19439656c38bbd143779ae0861b038ce82abd/grpcio-1.80.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4ed39fbdcf9b87370f6e8df4e39ca7b38b3e5e9d1b0013c7b6be9639d6578d14", size = 7277711, upload-time = "2026-03-30T08:48:19.627Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/f437a78f7f4f1d311804189e8f11fb311a01049b2e08557c1068d470cb2e/grpcio-1.80.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2dcc70e9f0ba987526e8e8603a610fb4f460e42899e74e7a518bf3c68fe1bf05", size = 6785372, upload-time = "2026-03-30T08:48:22.373Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3d/f6558e9c6296cb4227faa5c43c54a34c68d32654b829f53288313d16a86e/grpcio-1.80.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:448c884b668b868562b1bda833c5fce6272d26e1926ec46747cda05741d302c1", size = 7395268, upload-time = "2026-03-30T08:48:25.638Z" },
+    { url = "https://files.pythonhosted.org/packages/06/21/0fdd77e84720b08843c371a2efa6f2e19dbebf56adc72df73d891f5506f0/grpcio-1.80.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a1dc80fe55685b4a543555e6eef975303b36c8db1023b1599b094b92aa77965f", size = 8392000, upload-time = "2026-03-30T08:48:28.974Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/68/67f4947ed55d2e69f2cc199ab9fd85e0a0034d813bbeef84df6d2ba4d4b7/grpcio-1.80.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:31b9ac4ad1aa28ffee5503821fafd09e4da0a261ce1c1281c6c8da0423c83b6e", size = 7828477, upload-time = "2026-03-30T08:48:32.054Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b6/8d4096691b2e385e8271911a0de4f35f0a6c7d05aff7098e296c3de86939/grpcio-1.80.0-cp314-cp314-win32.whl", hash = "sha256:367ce30ba67d05e0592470428f0ec1c31714cab9ef19b8f2e37be1f4c7d32fae", size = 4218563, upload-time = "2026-03-30T08:48:34.538Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/8c/bbe6baf2557262834f2070cf668515fa308b2d38a4bbf771f8f7872a7036/grpcio-1.80.0-cp314-cp314-win_amd64.whl", hash = "sha256:3b01e1f5464c583d2f567b2e46ff0d516ef979978f72091fd81f5ab7fa6e2e7f", size = 5019457, upload-time = "2026-03-30T08:48:37.308Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "hf-xet"
+version = "1.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/92/ec9ad04d0b5728dca387a45af7bc98fbb0d73b2118759f5f6038b61a57e8/hf_xet-1.4.3.tar.gz", hash = "sha256:8ddedb73c8c08928c793df2f3401ec26f95be7f7e516a7bee2fbb546f6676113", size = 670477, upload-time = "2026-03-31T22:40:07.874Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/72/43/724d307b34e353da0abd476e02f72f735cdd2bc86082dee1b32ea0bfee1d/hf_xet-1.4.3-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:7551659ba4f1e1074e9623996f28c3873682530aee0a846b7f2f066239228144", size = 3800935, upload-time = "2026-03-31T22:39:49.618Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/d2/8bee5996b699262edb87dbb54118d287c0e1b2fc78af7cdc41857ba5e3c4/hf_xet-1.4.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:bee693ada985e7045997f05f081d0e12c4c08bd7626dc397f8a7c487e6c04f7f", size = 3558942, upload-time = "2026-03-31T22:39:47.938Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/a1/e993d09cbe251196fb60812b09a58901c468127b7259d2bf0f68bf6088eb/hf_xet-1.4.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21644b404bb0100fe3857892f752c4d09642586fd988e61501c95bbf44b393a3", size = 4207657, upload-time = "2026-03-31T22:39:39.69Z" },
+    { url = "https://files.pythonhosted.org/packages/64/44/9eb6d21e5c34c63e5e399803a6932fa983cabdf47c0ecbcfe7ea97684b8c/hf_xet-1.4.3-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:987f09cfe418237812896a6736b81b1af02a3a6dcb4b4944425c4c4fca7a7cf8", size = 3986765, upload-time = "2026-03-31T22:39:37.936Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/7b/8ad6f16fdb82f5f7284a34b5ec48645bd575bdcd2f6f0d1644775909c486/hf_xet-1.4.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:60cf7fc43a99da0a853345cf86d23738c03983ee5249613a6305d3e57a5dca74", size = 4188162, upload-time = "2026-03-31T22:39:58.382Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/c4/39d6e136cbeea9ca5a23aad4b33024319222adbdc059ebcda5fc7d9d5ff4/hf_xet-1.4.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2815a49a7a59f3e2edf0cf113ae88e8cb2ca2a221bf353fb60c609584f4884d4", size = 4424525, upload-time = "2026-03-31T22:40:00.225Z" },
+    { url = "https://files.pythonhosted.org/packages/46/f2/adc32dae6bdbc367853118b9878139ac869419a4ae7ba07185dc31251b76/hf_xet-1.4.3-cp313-cp313t-win_amd64.whl", hash = "sha256:42ee323265f1e6a81b0e11094564fb7f7e0ec75b5105ffd91ae63f403a11931b", size = 3671610, upload-time = "2026-03-31T22:40:10.42Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/19/25d897dcc3f81953e0c2cde9ec186c7a0fee413eb0c9a7a9130d87d94d3a/hf_xet-1.4.3-cp313-cp313t-win_arm64.whl", hash = "sha256:27c976ba60079fb8217f485b9c5c7fcd21c90b0367753805f87cb9f3cdc4418a", size = 3528529, upload-time = "2026-03-31T22:40:09.106Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/36/3e8f85ca9fe09b8de2b2e10c63b3b3353d7dda88a0b3d426dffbe7b8313b/hf_xet-1.4.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:5251d5ece3a81815bae9abab41cf7ddb7bcb8f56411bce0827f4a3071c92fdc6", size = 3801019, upload-time = "2026-03-31T22:39:56.651Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/9c/defb6cb1de28bccb7bd8d95f6e60f72a3d3fa4cb3d0329c26fb9a488bfe7/hf_xet-1.4.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1feb0f3abeacee143367c326a128a2e2b60868ec12a36c225afb1d6c5a05e6d2", size = 3558746, upload-time = "2026-03-31T22:39:54.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/bd/8d001191893178ff8e826e46ad5299446e62b93cd164e17b0ffea08832ec/hf_xet-1.4.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8b301fc150290ca90b4fccd079829b84bb4786747584ae08b94b4577d82fb791", size = 4207692, upload-time = "2026-03-31T22:39:46.246Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/48/6790b402803250e9936435613d3a78b9aaeee7973439f0918848dde58309/hf_xet-1.4.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:d972fbe95ddc0d3c0fc49b31a8a69f47db35c1e3699bf316421705741aab6653", size = 3986281, upload-time = "2026-03-31T22:39:44.648Z" },
+    { url = "https://files.pythonhosted.org/packages/51/56/ea62552fe53db652a9099eda600b032d75554d0e86c12a73824bfedef88b/hf_xet-1.4.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c5b48db1ee344a805a1b9bd2cda9b6b65fe77ed3787bd6e87ad5521141d317cd", size = 4187414, upload-time = "2026-03-31T22:40:04.951Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/f5/bc1456d4638061bea997e6d2db60a1a613d7b200e0755965ec312dc1ef79/hf_xet-1.4.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:22bdc1f5fb8b15bf2831440b91d1c9bbceeb7e10c81a12e8d75889996a5c9da8", size = 4424368, upload-time = "2026-03-31T22:40:06.347Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/76/ab597bae87e1f06d18d3ecb8ed7f0d3c9a37037fc32ce76233d369273c64/hf_xet-1.4.3-cp314-cp314t-win_amd64.whl", hash = "sha256:0392c79b7cf48418cd61478c1a925246cf10639f4cd9d94368d8ca1e8df9ea07", size = 3672280, upload-time = "2026-03-31T22:40:16.401Z" },
+    { url = "https://files.pythonhosted.org/packages/62/05/2e462d34e23a09a74d73785dbed71cc5dbad82a72eee2ad60a72a554155d/hf_xet-1.4.3-cp314-cp314t-win_arm64.whl", hash = "sha256:681c92a07796325778a79d76c67011764ecc9042a8c3579332b61b63ae512075", size = 3528945, upload-time = "2026-03-31T22:40:14.995Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/9f/9c23e4a447b8f83120798f9279d0297a4d1360bdbf59ef49ebec78fe2545/hf_xet-1.4.3-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d0da85329eaf196e03e90b84c2d0aca53bd4573d097a75f99609e80775f98025", size = 3805048, upload-time = "2026-03-31T22:39:53.105Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f8/7aacb8e5f4a7899d39c787b5984e912e6c18b11be136ef13947d7a66d265/hf_xet-1.4.3-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:e23717ce4186b265f69afa66e6f0069fe7efbf331546f5c313d00e123dc84583", size = 3562178, upload-time = "2026-03-31T22:39:51.295Z" },
+    { url = "https://files.pythonhosted.org/packages/df/9a/a24b26dc8a65f0ecc0fe5be981a19e61e7ca963b85e062c083f3a9100529/hf_xet-1.4.3-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc360b70c815bf340ed56c7b8c63aacf11762a4b099b2fe2c9bd6d6068668c08", size = 4212320, upload-time = "2026-03-31T22:39:42.922Z" },
+    { url = "https://files.pythonhosted.org/packages/53/60/46d493db155d2ee2801b71fb1b0fd67696359047fdd8caee2c914cc50c79/hf_xet-1.4.3-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:39f2d2e9654cd9b4319885733993807aab6de9dfbd34c42f0b78338d6617421f", size = 3991546, upload-time = "2026-03-31T22:39:41.335Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/f5/067363e1c96c6b17256910830d1b54099d06287e10f4ec6ec4e7e08371fc/hf_xet-1.4.3-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:49ad8a8cead2b56051aa84d7fce3e1335efe68df3cf6c058f22a65513885baac", size = 4193200, upload-time = "2026-03-31T22:40:01.936Z" },
+    { url = "https://files.pythonhosted.org/packages/42/4b/53951592882d9c23080c7644542fda34a3813104e9e11fa1a7d82d419cb8/hf_xet-1.4.3-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7716d62015477a70ea272d2d68cd7cad140f61c52ee452e133e139abfe2c17ba", size = 4429392, upload-time = "2026-03-31T22:40:03.492Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/21/75a6c175b4e79662ad8e62f46a40ce341d8d6b206b06b4320d07d55b188c/hf_xet-1.4.3-cp37-abi3-win_amd64.whl", hash = "sha256:6b591fcad34e272a5b02607485e4f2a1334aebf1bc6d16ce8eb1eb8978ac2021", size = 3677359, upload-time = "2026-03-31T22:40:13.619Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/7c/44314ecd0e89f8b2b51c9d9e5e7a60a9c1c82024ac471d415860557d3cd8/hf_xet-1.4.3-cp37-abi3-win_arm64.whl", hash = "sha256:7c2c7e20bcfcc946dc67187c203463f5e932e395845d098cc2a93f5b67ca0b47", size = 3533664, upload-time = "2026-03-31T22:40:12.152Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "httpx-sse"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
+]
+
+[[package]]
+name = "huggingface-hub"
+version = "1.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "fsspec" },
+    { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
+    { name = "httpx" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "tqdm" },
+    { name = "typer" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/28/baf5d745559503ce8d28cf5bc9551f5ac59158eafd7b6a6afff0bcdb0f50/huggingface_hub-1.10.1.tar.gz", hash = "sha256:696c53cf9c2ac9befbfb5dd41d05392a031c69fc6930d1ed9671debd405b6fff", size = 758094, upload-time = "2026-04-09T15:01:18.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/8c/c7a33f3efaa8d6a5bc40e012e5ecc2d72c2e6124550ca9085fe0ceed9993/huggingface_hub-1.10.1-py3-none-any.whl", hash = "sha256:6b981107a62fbe68c74374418983399c632e35786dcd14642a9f2972633c8b5a", size = 642630, upload-time = "2026-04-09T15:01:17.35Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jaraco-classes"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "more-itertools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" },
+]
+
+[[package]]
+name = "jaraco-context"
+version = "6.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871, upload-time = "2026-03-20T22:13:32.808Z" },
+]
+
+[[package]]
+name = "jaraco-functools"
+version = "4.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "more-itertools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0f/27/056e0638a86749374d6f57d0b0db39f29509cce9313cf91bdc0ac4d91084/jaraco_functools-4.4.0.tar.gz", hash = "sha256:da21933b0417b89515562656547a77b4931f98176eb173644c0d35032a33d6bb", size = 19943, upload-time = "2025-12-21T09:29:43.6Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/c4/813bb09f0985cb21e959f21f2464169eca882656849adf727ac7bb7e1767/jaraco_functools-4.4.0-py3-none-any.whl", hash = "sha256:9eec1e36f45c818d9bf307c8948eb03b2b56cd44087b3cdc989abca1f20b9176", size = 10481, upload-time = "2025-12-21T09:29:42.27Z" },
+]
+
+[[package]]
+name = "jeepney"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" },
+]
+
+[[package]]
+name = "jiter"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6e/c1/0cddc6eb17d4c53a99840953f95dd3accdc5cfc7a337b0e9b26476276be9/jiter-0.14.0.tar.gz", hash = "sha256:e8a39e66dac7153cf3f964a12aad515afa8d74938ec5cc0018adcdae5367c79e", size = 165725, upload-time = "2026-04-10T14:28:42.01Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/68/7390a418f10897da93b158f2d5a8bd0bcd73a0f9ec3bb36917085bb759ef/jiter-0.14.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:2fb2ce3a7bc331256dfb14cefc34832366bb28a9aca81deaf43bbf2a5659e607", size = 316295, upload-time = "2026-04-10T14:26:24.887Z" },
+    { url = "https://files.pythonhosted.org/packages/60/a0/5854ac00ff63551c52c6c89534ec6aba4b93474e7924d64e860b1c94165b/jiter-0.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5252a7ca23785cef5d02d4ece6077a1b556a410c591b379f82091c3001e14844", size = 315898, upload-time = "2026-04-10T14:26:26.601Z" },
+    { url = "https://files.pythonhosted.org/packages/41/a1/4f44832650a16b18e8391f1bf1d6ca4909bc738351826bcc198bba4357f4/jiter-0.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c409578cbd77c338975670ada777add4efd53379667edf0aceea730cabede6fb", size = 343730, upload-time = "2026-04-10T14:26:28.326Z" },
+    { url = "https://files.pythonhosted.org/packages/48/64/a329e9d469f86307203594b1707e11ae51c3348d03bfd514a5f997870012/jiter-0.14.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7ede4331a1899d604463369c730dbb961ffdc5312bc7f16c41c2896415b1304a", size = 370102, upload-time = "2026-04-10T14:26:30.089Z" },
+    { url = "https://files.pythonhosted.org/packages/94/c1/5e3dfc59635aa4d4c7bd20a820ac1d09b8ed851568356802cf1c08edb3cf/jiter-0.14.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:92cd8b6025981a041f5310430310b55b25ca593972c16407af8837d3d7d2ca01", size = 461335, upload-time = "2026-04-10T14:26:31.911Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/1b/dd157009dbc058f7b00108f545ccb72a2d56461395c4fc7b9cfdccb00af4/jiter-0.14.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:351bf6eda4e3a7ceb876377840c702e9a3e4ecc4624dbfb2d6463c67ae52637d", size = 378536, upload-time = "2026-04-10T14:26:33.595Z" },
+    { url = "https://files.pythonhosted.org/packages/91/78/256013667b7c10b8834f8e6e54cd3e562d4c6e34227a1596addccc05e38c/jiter-0.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1dcfbeb93d9ecd9ca128bbf8910120367777973fa193fb9a39c31237d8df165", size = 353859, upload-time = "2026-04-10T14:26:35.098Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d9/137d65ade9093a409fe80955ce60b12bb753722c986467aeda47faf450ad/jiter-0.14.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:ae039aaef8de3f8157ecc1fdd4d85043ac4f57538c245a0afaecb8321ec951c3", size = 357626, upload-time = "2026-04-10T14:26:36.685Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/48/76750835b87029342727c1a268bea8878ab988caf81ee4e7b880900eeb5a/jiter-0.14.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7d9d51eb96c82a9652933bd769fe6de66877d6eb2b2440e281f2938c51b5643e", size = 393172, upload-time = "2026-04-10T14:26:38.097Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/60/456c4e81d5c8045279aefe60e9e483be08793828800a4e64add8fdde7f2a/jiter-0.14.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d824ca4148b705970bf4e120924a212fdfca9859a73e42bd7889a63a4ea6bb98", size = 520300, upload-time = "2026-04-10T14:26:39.532Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/9f/2020e0984c235f678dced38fe4eec3058cf528e6af36ebf969b410305941/jiter-0.14.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ff3a6465b3a0f54b1a430f45c3c0ba7d61ceb45cbc3e33f9e1a7f638d690baf3", size = 553059, upload-time = "2026-04-10T14:26:40.991Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/32/e2d298e1a22a4bbe6062136d1c7192db7dba003a6975e51d9a9eecabc4c2/jiter-0.14.0-cp312-cp312-win32.whl", hash = "sha256:5dec7c0a3e98d2a3f8a2e67382d0d7c3ac60c69103a4b271da889b4e8bb1e129", size = 206030, upload-time = "2026-04-10T14:26:42.517Z" },
+    { url = "https://files.pythonhosted.org/packages/36/ac/96369141b3d8a4a8e4590e983085efe1c436f35c0cda940dd76d942e3e40/jiter-0.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:fc7e37b4b8bc7e80a63ad6cfa5fc11fab27dbfea4cc4ae644b1ab3f273dc348f", size = 201603, upload-time = "2026-04-10T14:26:44.328Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c3/75d847f264647017d7e3052bbcc8b1e24b95fa139c320c5f5066fa7a0bdd/jiter-0.14.0-cp312-cp312-win_arm64.whl", hash = "sha256:ee4a72f12847ef29b072aee9ad5474041ab2924106bdca9fcf5d7d965853e057", size = 191525, upload-time = "2026-04-10T14:26:46Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2a/09f70020898507a89279659a1afe3364d57fc1b2c89949081975d135f6f5/jiter-0.14.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:af72f204cf4d44258e5b4c1745130ac45ddab0e71a06333b01de660ab4187a94", size = 315502, upload-time = "2026-04-10T14:26:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/be/080c96a45cd74f9fce5db4fd68510b88087fb37ffe2541ff73c12db92535/jiter-0.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4b77da71f6e819be5fbcec11a453fde5b1d0267ef6ed487e2a392fd8e14e4e3a", size = 314870, upload-time = "2026-04-10T14:26:49.149Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/5e/2d0fee155826a968a832cc32438de5e2a193292c8721ca70d0b53e58245b/jiter-0.14.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f4ea612fe8b84b8b04e51d0e78029ecf3466348e25973f953de6e6a59aa4c1", size = 343406, upload-time = "2026-04-10T14:26:50.762Z" },
+    { url = "https://files.pythonhosted.org/packages/70/af/bf9ee0d3a4f8dc0d679fc1337f874fe60cdbf841ebbb304b374e1c9aaceb/jiter-0.14.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:62fe2451f8fcc0240261e6a4df18ecbcd58327857e61e625b2393ea3b468aac9", size = 369415, upload-time = "2026-04-10T14:26:52.188Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/83/8e8561eadba31f4d3948a5b712fb0447ec71c3560b57a855449e7b8ddc98/jiter-0.14.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6112f26f5afc75bcb475787d29da3aa92f9d09c7858f632f4be6ffe607be82e9", size = 461456, upload-time = "2026-04-10T14:26:53.611Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/c9/c5299e826a5fe6108d172b344033f61c69b1bb979dd8d9ddd4278a160971/jiter-0.14.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:215a6cb8fb7dc702aa35d475cc00ddc7f970e5c0b1417fb4b4ac5d82fa2a29db", size = 378488, upload-time = "2026-04-10T14:26:55.211Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/37/c16d9d15c0a471b8644b1abe3c82668092a707d9bedcf076f24ff2e380cd/jiter-0.14.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc4ab96a30fb3cb2c7e0cd33f7616c8860da5f5674438988a54ac717caccdbaa", size = 353242, upload-time = "2026-04-10T14:26:56.705Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ea/8050cb0dc654e728e1bfacbc0c640772f2181af5dedd13ae70145743a439/jiter-0.14.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:3a99c1387b1f2928f799a9de899193484d66206a50e98233b6b088a7f0c1edb2", size = 356823, upload-time = "2026-04-10T14:26:58.281Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/cf71506d270e5f84d97326bf220e47aed9b95e9a4a060758fb07772170ab/jiter-0.14.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ab18d11074485438695f8d34a1b6da61db9754248f96d51341956607a8f39985", size = 392564, upload-time = "2026-04-10T14:27:00.018Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/cc/8c6c74a3efb5bd671bfd14f51e8a73375464ca914b1551bc3b40e26ac2c9/jiter-0.14.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:801028dcfc26ac0895e4964cbc0fd62c73be9fd4a7d7b1aaf6e5790033a719b7", size = 520322, upload-time = "2026-04-10T14:27:01.664Z" },
+    { url = "https://files.pythonhosted.org/packages/41/24/68d7b883ec959884ddf00d019b2e0e82ba81b167e1253684fa90519ce33c/jiter-0.14.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ad425b087aafb4a1c7e1e98a279200743b9aaf30c3e0ba723aec93f061bd9bc8", size = 552619, upload-time = "2026-04-10T14:27:03.316Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/89/b1a0985223bbf3150ff9e8f46f98fc9360c1de94f48abe271bbe1b465682/jiter-0.14.0-cp313-cp313-win32.whl", hash = "sha256:882bcb9b334318e233950b8be366fe5f92c86b66a7e449e76975dfd6d776a01f", size = 205699, upload-time = "2026-04-10T14:27:04.662Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/19/3f339a5a7f14a11730e67f6be34f9d5105751d547b615ef593fa122a5ded/jiter-0.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:9b8c571a5dba09b98bd3462b5a53f27209a5cbbe85670391692ede71974e979f", size = 201323, upload-time = "2026-04-10T14:27:06.139Z" },
+    { url = "https://files.pythonhosted.org/packages/50/56/752dd89c84be0e022a8ea3720bcfa0a8431db79a962578544812ce061739/jiter-0.14.0-cp313-cp313-win_arm64.whl", hash = "sha256:34f19dcc35cb1abe7c369b3756babf8c7f04595c0807a848df8f26ef8298ef92", size = 191099, upload-time = "2026-04-10T14:27:07.564Z" },
+    { url = "https://files.pythonhosted.org/packages/91/28/292916f354f25a1fe8cf2c918d1415c699a4a659ae00be0430e1c5d9ffea/jiter-0.14.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e89bcd7d426a75bb4952c696b267075790d854a07aad4c9894551a82c5b574ab", size = 320880, upload-time = "2026-04-10T14:27:09.326Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/c7/b002a7d8b8957ac3d469bd59c18ef4b1595a5216ae0de639a287b9816023/jiter-0.14.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b25beaa0d4447ea8c7ae0c18c688905d34840d7d0b937f2f7bdd52162c98a40", size = 346563, upload-time = "2026-04-10T14:27:11.287Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/3b/f8d07580d8706021d255a6356b8fab13ee4c869412995550ce6ed4ddf97d/jiter-0.14.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:651a8758dd413c51e3b7f6557cdc6921faf70b14106f45f969f091f5cda990ea", size = 357928, upload-time = "2026-04-10T14:27:12.729Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5b/ac1a974da29e35507230383110ffec59998b290a8732585d04e19a9eb5ba/jiter-0.14.0-cp313-cp313t-win_amd64.whl", hash = "sha256:e1a7eead856a5038a8d291f1447176ab0b525c77a279a058121b5fccee257f6f", size = 203519, upload-time = "2026-04-10T14:27:14.125Z" },
+    { url = "https://files.pythonhosted.org/packages/96/6d/9fc8433d667d2454271378a79747d8c76c10b51b482b454e6190e511f244/jiter-0.14.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e692633a12cda97e352fdcd1c4acc971b1c28707e1e33aeef782b0cbf051975", size = 190113, upload-time = "2026-04-10T14:27:16.638Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/1e/354ed92461b165bd581f9ef5150971a572c873ec3b68a916d5aa91da3cc2/jiter-0.14.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:6f396837fc7577871ca8c12edaf239ed9ccef3bbe39904ae9b8b63ce0a48b140", size = 315277, upload-time = "2026-04-10T14:27:18.109Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/95/8c7c7028aa8636ac21b7a55faef3e34215e6ed0cbf5ae58258427f621aa3/jiter-0.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a4d50ea3d8ba4176f79754333bd35f1bbcd28e91adc13eb9b7ca91bc52a6cef9", size = 315923, upload-time = "2026-04-10T14:27:19.603Z" },
+    { url = "https://files.pythonhosted.org/packages/47/40/e2a852a44c4a089f2681a16611b7ce113224a80fd8504c46d78491b47220/jiter-0.14.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce17f8a050447d1b4153bda4fb7d26e6a9e74eb4f4a41913f30934c5075bf615", size = 344943, upload-time = "2026-04-10T14:27:21.262Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/1f/670f92adee1e9895eac41e8a4d623b6da68c4d46249d8b556b60b63f949e/jiter-0.14.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4f1c4b125e1652aefbc2e2c1617b60a160ab789d180e3d423c41439e5f32850", size = 369725, upload-time = "2026-04-10T14:27:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/01/2f/541c9ba567d05de1c4874a0f8f8c5e3fd78e2b874266623da9a775cf46e0/jiter-0.14.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be808176a6a3a14321d18c603f2d40741858a7c4fc982f83232842689fe86dd9", size = 461210, upload-time = "2026-04-10T14:27:24.315Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/a9/c31cbec09627e0d5de7aeaec7690dba03e090caa808fefd8133137cf45bc/jiter-0.14.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26679d58ba816f88c3849306dd58cb863a90a1cf352cdd4ef67e30ccf8a77994", size = 380002, upload-time = "2026-04-10T14:27:26.155Z" },
+    { url = "https://files.pythonhosted.org/packages/50/02/3c05c1666c41904a2f607475a73e7a4763d1cbde2d18229c4f85b22dc253/jiter-0.14.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80381f5a19af8fa9aef743f080e34f6b25ebd89656475f8cf0470ec6157052aa", size = 354678, upload-time = "2026-04-10T14:27:27.701Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/97/e15b33545c2b13518f560d695f974b9891b311641bdcf178d63177e8801e/jiter-0.14.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:004df5fdb8ecbd6d99f3227df18ba1a259254c4359736a2e6f036c944e02d7c5", size = 358920, upload-time = "2026-04-10T14:27:29.256Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/d2/8b1461def6b96ba44530df20d07ef7a1c7da22f3f9bf1727e2d611077bf1/jiter-0.14.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cff5708f7ed0fa098f2b53446c6fa74c48469118e5cd7497b4f1cd569ab06928", size = 394512, upload-time = "2026-04-10T14:27:31.344Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/88/837566dd6ed6e452e8d3205355afd484ce44b2533edfa4ed73a298ea893e/jiter-0.14.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:2492e5f06c36a976d25c7cc347a60e26d5470178d44cde1b9b75e60b4e519f28", size = 521120, upload-time = "2026-04-10T14:27:33.299Z" },
+    { url = "https://files.pythonhosted.org/packages/89/6b/b00b45c4d1b4c031777fe161d620b755b5b02cdade1e316dcb46e4471d63/jiter-0.14.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:7609cfbe3a03d37bfdbf5052012d5a879e72b83168a363deae7b3a26564d57de", size = 553668, upload-time = "2026-04-10T14:27:34.868Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/d8/6fe5b42011d19397433d345716eac16728ac241862a2aac9c91923c7509a/jiter-0.14.0-cp314-cp314-win32.whl", hash = "sha256:7282342d32e357543565286b6450378c3cd402eea333fc1ebe146f1fabb306fc", size = 207001, upload-time = "2026-04-10T14:27:36.455Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/43/5c2e08da1efad5e410f0eaaabeadd954812612c33fbbd8fd5328b489139d/jiter-0.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:bd77945f38866a448e73b0b7637366afa814d4617790ecd88a18ca74377e6c02", size = 202187, upload-time = "2026-04-10T14:27:38Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/6e39ac0b4cdfa23e606af5b245df5f9adaa76f35e0c5096790da430ca506/jiter-0.14.0-cp314-cp314-win_arm64.whl", hash = "sha256:f2d4c61da0821ee42e0cdf5489da60a6d074306313a377c2b35af464955a3611", size = 192257, upload-time = "2026-04-10T14:27:39.504Z" },
+    { url = "https://files.pythonhosted.org/packages/05/57/7dbc0ffbbb5176a27e3518716608aa464aee2e2887dc938f0b900a120449/jiter-0.14.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1bf7ff85517dd2f20a5750081d2b75083c1b269cf75afc7511bdf1f9548beb3b", size = 323441, upload-time = "2026-04-10T14:27:41.039Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6e/7b3314398d8983f06b557aa21b670511ec72d3b79a68ee5e4d9bff972286/jiter-0.14.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8ef8791c3e78d6c6b157c6d360fbb5c715bebb8113bc6a9303c5caff012754a", size = 348109, upload-time = "2026-04-10T14:27:42.552Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/4f/8dc674bcd7db6dba566de73c08c763c337058baff1dbeb34567045b27cdc/jiter-0.14.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e74663b8b10da1fe0f4e4703fd7980d24ad17174b6bb35d8498d6e3ebce2ae6a", size = 368328, upload-time = "2026-04-10T14:27:44.574Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/5f/188e09a1f20906f98bbdec44ed820e19f4e8eb8aff88b9d1a5a497587ff3/jiter-0.14.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1aca29ba52913f78362ec9c2da62f22cdc4c3083313403f90c15460979b84d9b", size = 463301, upload-time = "2026-04-10T14:27:46.717Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/f0/19046ef965ed8f349e8554775bb12ff4352f443fbe12b95d31f575891256/jiter-0.14.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8b39b7d87a952b79949af5fef44d2544e58c21a28da7f1bae3ef166455c61746", size = 378891, upload-time = "2026-04-10T14:27:48.32Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/c3/da43bd8431ee175695777ee78cf0e93eacbb47393ff493f18c45231b427d/jiter-0.14.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78d918a68b26e9fab068c2b5453577ef04943ab2807b9a6275df2a812599a310", size = 360749, upload-time = "2026-04-10T14:27:49.88Z" },
+    { url = "https://files.pythonhosted.org/packages/72/26/e054771be889707c6161dbdec9c23d33a9ec70945395d70f07cfea1e9a6f/jiter-0.14.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:b08997c35aee1201c1a5361466a8fb9162d03ae7bf6568df70b6c859f1e654a4", size = 358526, upload-time = "2026-04-10T14:27:51.504Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/0f/7bea65ea2a6d91f2bf989ff11a18136644392bf2b0497a1fa50934c30a9c/jiter-0.14.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:260bf7ca20704d58d41f669e5e9fe7fe2fa72901a6b324e79056f5d52e9c9be2", size = 393926, upload-time = "2026-04-10T14:27:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/b1ff7d70deef61ac0b7c6c2f12d2ace950cdeecb4fdc94500a0926802857/jiter-0.14.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:37826e3df29e60f30a382f9294348d0238ef127f4b5d7f5f8da78b5b9e050560", size = 521052, upload-time = "2026-04-10T14:27:55.058Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/7b/3b0649983cbaf15eda26a414b5b1982e910c67bd6f7b1b490f3cfc76896a/jiter-0.14.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:645be49c46f2900937ba0eaf871ad5183c96858c0af74b6becc7f4e367e36e06", size = 553716, upload-time = "2026-04-10T14:27:57.269Z" },
+    { url = "https://files.pythonhosted.org/packages/97/f8/33d78c83bd93ae0c0af05293a6660f88a1977caef39a6d72a84afab94ce0/jiter-0.14.0-cp314-cp314t-win32.whl", hash = "sha256:2f7877ed45118de283786178eceaf877110abacd04fde31efff3940ae9672674", size = 207957, upload-time = "2026-04-10T14:27:59.285Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/ac/2b760516c03e2227826d1f7025d89bf6bf6357a28fe75c2a2800873c50bf/jiter-0.14.0-cp314-cp314t-win_amd64.whl", hash = "sha256:14c0cb10337c49f5eafe8e7364daca5e29a020ea03580b8f8e6c597fed4e1588", size = 204690, upload-time = "2026-04-10T14:28:00.962Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/2e/a44c20c58aeed0355f2d326969a181696aeb551a25195f47563908a815be/jiter-0.14.0-cp314-cp314t-win_arm64.whl", hash = "sha256:5419d4aa2024961da9fe12a9cfe7484996735dca99e8e090b5c88595ef1951ff", size = 191338, upload-time = "2026-04-10T14:28:02.853Z" },
+    { url = "https://files.pythonhosted.org/packages/21/42/9042c3f3019de4adcb8c16591c325ec7255beea9fcd33a42a43f3b0b1000/jiter-0.14.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:fbd9e482663ca9d005d051330e4d2d8150bb208a209409c10f7e7dfdf7c49da9", size = 308810, upload-time = "2026-04-10T14:28:34.673Z" },
+    { url = "https://files.pythonhosted.org/packages/60/cf/a7e19b308bd86bb04776803b1f01a5f9a287a4c55205f4708827ee487fbf/jiter-0.14.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:33a20d838b91ef376b3a56896d5b04e725c7df5bc4864cc6569cf046a8d73b6d", size = 308443, upload-time = "2026-04-10T14:28:36.658Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/44/e26ede3f0caeff93f222559cb0cc4ca68579f07d009d7b6010c5b586f9b1/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:432c4db5255d86a259efde91e55cb4c8d18c0521d844c9e2e7efcce3899fb016", size = 343039, upload-time = "2026-04-10T14:28:38.356Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e9/1f9ada30cef7b05e74bb06f52127e7a724976c225f46adb65c37b1dadfb6/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67f00d94b281174144d6532a04b66a12cb866cbdc47c3af3bfe2973677f9861a", size = 349613, upload-time = "2026-04-10T14:28:40.066Z" },
+]
+
+[[package]]
+name = "jmespath"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
+]
+
+[[package]]
+name = "jsonpath-python"
+version = "1.1.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/db/2f4ecc24da35c6142b39c353d5b7c16eef955cc94b35a48d3fa47996d7c3/jsonpath_python-1.1.5.tar.gz", hash = "sha256:ceea2efd9e56add09330a2c9631ea3d55297b9619348c1055e5bfb9cb0b8c538", size = 87352, upload-time = "2026-03-17T06:16:40.597Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/28/50/1a313fb700526b134c71eb8a225d8b83be0385dbb0204337b4379c698cef/jsonpath_python-1.1.5-py3-none-any.whl", hash = "sha256:a60315404d70a65e76c9a782c84e50600480221d94a58af47b7b4d437351cb4b", size = 14090, upload-time = "2026-03-17T06:16:39.152Z" },
+]
+
+[[package]]
+name = "jsonref"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", hash = "sha256:32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552", size = 8814, upload-time = "2023-01-16T16:10:04.455Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", hash = "sha256:590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9", size = 9425, upload-time = "2023-01-16T16:10:02.255Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[[package]]
+name = "jsonschema-path"
+version = "0.4.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pathable" },
+    { name = "pyyaml" },
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/8a/7e6102f2b8bdc6705a9eb5294f8f6f9ccd3a8420e8e8e19671d1dd773251/jsonschema_path-0.4.5.tar.gz", hash = "sha256:c6cd7d577ae290c7defd4f4029e86fdb248ca1bd41a07557795b3c95e5144918", size = 15113, upload-time = "2026-03-03T09:56:46.87Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/d5/4e96c44f6c1ea3d812cf5391d81a4f5abaa540abf8d04ecd7f66e0ed11df/jsonschema_path-0.4.5-py3-none-any.whl", hash = "sha256:7d77a2c3f3ec569a40efe5c5f942c44c1af2a6f96fe0866794c9ef5b8f87fd65", size = 19368, upload-time = "2026-03-03T09:56:45.39Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "keyring"
+version = "25.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jaraco-classes" },
+    { name = "jaraco-context" },
+    { name = "jaraco-functools" },
+    { name = "jeepney", marker = "sys_platform == 'linux'" },
+    { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" },
+    { name = "secretstorage", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" },
+]
+
+[[package]]
+name = "logfire"
+version = "4.32.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "executing" },
+    { name = "opentelemetry-exporter-otlp-proto-http" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-sdk" },
+    { name = "protobuf" },
+    { name = "rich" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/64/f927d4f9de1f1371047b9016adba1ec2e08258301708d548d41f86f27772/logfire-4.32.0.tar.gz", hash = "sha256:f1dc9d756a4b28f0483645244aaf3ea8535b8e2ae5a1068442a968ca0c746304", size = 1088575, upload-time = "2026-04-10T19:36:54.172Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/33/81b13e1f2044b5fe0112068a2494526db9cfdf784030a2ea57688279360a/logfire-4.32.0-py3-none-any.whl", hash = "sha256:d9cff51c3c093c4161ece87a65e6ac6e2d862258b62494c30d93d713e9858758", size = 312412, upload-time = "2026-04-10T19:36:50.97Z" },
+]
+
+[package.optional-dependencies]
+httpx = [
+    { name = "opentelemetry-instrumentation-httpx" },
+]
+
+[[package]]
+name = "logfire-api"
+version = "4.32.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cb/17/7a50c55077e50b088e056a90e0754836ee6f1cb31ba6a2cd7f4282afd70b/logfire_api-4.32.0.tar.gz", hash = "sha256:aae7d7f1e38d04c6fa9449b15b18cc77336474feae56afc507e6f053aa1afb83", size = 78813, upload-time = "2026-04-10T19:36:55.69Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/56/fe8d8aa60e796e059992fb7359ec5dda4ef72db4fccfbd362a2ee0595ec1/logfire_api-4.32.0-py3-none-any.whl", hash = "sha256:062526b31ca5e4bde5455bd5230bfb713df23189aedb370c8c47c6ed8ec02a37", size = 124427, upload-time = "2026-04-10T19:36:52.695Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[[package]]
+name = "mcp"
+version = "1.27.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "httpx" },
+    { name = "httpx-sse" },
+    { name = "jsonschema" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "pyjwt", extra = ["crypto"] },
+    { name = "python-multipart" },
+    { name = "pywin32", marker = "sys_platform == 'win32'" },
+    { name = "sse-starlette" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8b/eb/c0cfc62075dc6e1ec1c64d352ae09ac051d9334311ed226f1f425312848a/mcp-1.27.0.tar.gz", hash = "sha256:d3dc35a7eec0d458c1da4976a48f982097ddaab87e278c5511d5a4a56e852b83", size = 607509, upload-time = "2026-04-02T14:48:08.88Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/46/f6b4ad632c67ef35209a66127e4bddc95759649dd595f71f13fba11bdf9a/mcp-1.27.0-py3-none-any.whl", hash = "sha256:5ce1fa81614958e267b21fb2aa34e0aea8e2c6ede60d52aba45fd47246b4d741", size = 215967, upload-time = "2026-04-02T14:48:07.24Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mistralai"
+version = "2.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "eval-type-backport" },
+    { name = "httpx" },
+    { name = "jsonpath-python" },
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "pydantic" },
+    { name = "python-dateutil" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5c/08/f8fed64eab35ad1ded82f92bf834160302db19f5bbda5a904df7d4dbf3c4/mistralai-2.3.2.tar.gz", hash = "sha256:a02c7e90ac165e8680c849551ff5fe9788e9fc10b7dbe71817443dc63cc5e9c9", size = 394665, upload-time = "2026-04-10T14:05:36.31Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/e0/9f246d18f8fe6e815f7cae88c437c986b342d3ff568607c8e0d53f4710d0/mistralai-2.3.2-py3-none-any.whl", hash = "sha256:dec05f446502289b76add9796d75465c070fc539b3c01d6f7d3297833bb64981", size = 935914, upload-time = "2026-04-10T14:05:37.845Z" },
+]
+
+[[package]]
+name = "molcrafts-molcfg"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/10/e7/1b8e976193f9c039dc8377d807c7d46febed90ece1ac7e66defe444f6ab5/molcrafts_molcfg-1.1.0.tar.gz", hash = "sha256:ecdfe5c7885fd34b798bd2ae1e2d719256e86d1f249ee60f38f9cadf4e16d369", size = 28109, upload-time = "2026-04-12T22:39:36.139Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/5e/4a6301b218000cf4015fa1d5547626959c8ab84dc5b4a832404476999f91/molcrafts_molcfg-1.1.0-py3-none-any.whl", hash = "sha256:f9cf35873a2985ae405e59ff6eb061025e6cb36769cfa0541ef984f011562b9f", size = 15614, upload-time = "2026-04-12T22:39:34.636Z" },
+]
+
+[[package]]
+name = "molcrafts-mollog"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/7f/f1d779d1bae794944bfd3926b841605595c6ae3e0c759557cacd72ecdb23/molcrafts_mollog-1.0.0.tar.gz", hash = "sha256:f434bea996dd37e58123342a68c3f9ac9e5170f8f25c990bc4fa4b8f81f7008b", size = 26368, upload-time = "2026-04-11T22:14:54.909Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/b5/62304f457549c417df0a97017980ada61fedc22eeefd85166ef8efedfb3e/molcrafts_mollog-1.0.0-py3-none-any.whl", hash = "sha256:4bf8d3aafef0bbf3df1b67f0fb8a243aa9ce51926f4fd4c080f86c03ab24973e", size = 15832, upload-time = "2026-04-11T22:14:53.522Z" },
+]
+
+[[package]]
+name = "molexp"
+version = "0.2.0"
+source = { editable = "." }
+dependencies = [
+    { name = "fastapi" },
+    { name = "molcrafts-molcfg" },
+    { name = "molcrafts-mollog" },
+    { name = "pydantic" },
+    { name = "pydantic-graph" },
+    { name = "pyyaml" },
+    { name = "rich" },
+    { name = "typer" },
+    { name = "uvicorn" },
+]
+
+[package.optional-dependencies]
+agent = [
+    { name = "pydantic-ai" },
+]
+all = [
+    { name = "pydantic-ai" },
+]
+dev = [
+    { name = "httpx" },
+    { name = "psutil" },
+    { name = "pydantic-ai" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "fastapi", specifier = ">=0.100.0" },
+    { name = "httpx", marker = "extra == 'dev'", specifier = ">=0.24" },
+    { name = "molcrafts-molcfg", specifier = ">=1.0.0" },
+    { name = "molcrafts-mollog", specifier = ">=1.0.0" },
+    { name = "molexp", extras = ["agent", "remote"], marker = "extra == 'all'" },
+    { name = "molexp", extras = ["all"], marker = "extra == 'dev'" },
+    { name = "psutil", marker = "extra == 'dev'", specifier = ">=5.9.0" },
+    { name = "pydantic", specifier = ">=2.10" },
+    { name = "pydantic-ai", marker = "extra == 'agent'", specifier = ">=1.0" },
+    { name = "pydantic-graph", specifier = ">=1.0" },
+    { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0" },
+    { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.21" },
+    { name = "pyyaml", specifier = ">=6.0" },
+    { name = "rich", specifier = ">=13.0.0" },
+    { name = "typer", specifier = ">=0.9.0" },
+    { name = "uvicorn", specifier = ">=0.23.0" },
+]
+provides-extras = ["agent", "remote", "all", "dev"]
+
+[[package]]
+name = "more-itertools"
+version = "11.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/f7/139d22fef48ac78127d18e01d80cf1be40236ae489769d17f35c3d425293/more_itertools-11.0.2.tar.gz", hash = "sha256:392a9e1e362cbc106a2457d37cabf9b36e5e12efd4ebff1654630e76597df804", size = 144659, upload-time = "2026-04-09T15:01:33.297Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/98/6af411189d9413534c3eb691182bff1f5c6d44ed2f93f2edfe52a1bbceb8/more_itertools-11.0.2-py3-none-any.whl", hash = "sha256:6e35b35f818b01f691643c6c611bc0902f2e92b46c18fffa77ae1e7c46e912e4", size = 71939, upload-time = "2026-04-09T15:01:32.21Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" },
+    { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" },
+    { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" },
+    { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" },
+    { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" },
+    { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" },
+    { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" },
+    { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" },
+    { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" },
+    { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "nexus-rpc"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/35/d5/cd1ffb202b76ebc1b33c1332a3416e55a39929006982adc2b1eb069aaa9b/nexus_rpc-1.4.0.tar.gz", hash = "sha256:3b8b373d4865671789cc43623e3dc0bcbf192562e40e13727e17f1c149050fba", size = 82367, upload-time = "2026-02-25T22:01:34.053Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/52/6327a5f4fda01207205038a106a99848a41c83e933cd23ea2cab3d2ebc6c/nexus_rpc-1.4.0-py3-none-any.whl", hash = "sha256:14c953d3519113f8ccec533a9efdb6b10c28afef75d11cdd6d422640c40b3a49", size = 29645, upload-time = "2026-02-25T22:01:33.122Z" },
+]
+
+[[package]]
+name = "openai"
+version = "2.31.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "httpx" },
+    { name = "jiter" },
+    { name = "pydantic" },
+    { name = "sniffio" },
+    { name = "tqdm" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/94/fe/64b3d035780b3188f86c4f6f1bc202e7bb74757ef028802112273b9dcacf/openai-2.31.0.tar.gz", hash = "sha256:43ca59a88fc973ad1848d86b98d7fac207e265ebbd1828b5e4bdfc85f79427a5", size = 684772, upload-time = "2026-04-08T21:01:41.797Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/66/bc/a8f7c3aa03452fedbb9af8be83e959adba96a6b4a35e416faffcc959c568/openai-2.31.0-py3-none-any.whl", hash = "sha256:44e1344d87e56a493d649b17e2fac519d1368cbb0745f59f1957c4c26de50a0a", size = 1153479, upload-time = "2026-04-08T21:01:39.217Z" },
+]
+
+[[package]]
+name = "openapi-pydantic"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/02/2e/58d83848dd1a79cb92ed8e63f6ba901ca282c5f09d04af9423ec26c56fd7/openapi_pydantic-0.5.1.tar.gz", hash = "sha256:ff6835af6bde7a459fb93eb93bb92b8749b754fc6e51b2f1590a19dc3005ee0d", size = 60892, upload-time = "2025-01-08T19:29:27.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/cf/03675d8bd8ecbf4445504d8071adab19f5f993676795708e36402ab38263/openapi_pydantic-0.5.1-py3-none-any.whl", hash = "sha256:a3a09ef4586f5bd760a8df7f43028b60cafb6d9f61de2acba9574766255ab146", size = 96381, upload-time = "2025-01-08T19:29:25.275Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/97/b9/3161be15bb8e3ad01be8be5a968a9237c3027c5be504362ff800fca3e442/opentelemetry_api-1.39.1.tar.gz", hash = "sha256:fbde8c80e1b937a2c61f20347e91c0c18a1940cecf012d62e65a7caf08967c9c", size = 65767, upload-time = "2025-12-11T13:32:39.182Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/df/d3f1ddf4bb4cb50ed9b1139cc7b1c54c34a1e7ce8fd1b9a37c0d1551a6bd/opentelemetry_api-1.39.1-py3-none-any.whl", hash = "sha256:2edd8463432a7f8443edce90972169b195e7d6a05500cd29e6d13898187c9950", size = 66356, upload-time = "2025-12-11T13:32:17.304Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-proto-common"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-proto" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/9d/22d241b66f7bbde88a3bfa6847a351d2c46b84de23e71222c6aae25c7050/opentelemetry_exporter_otlp_proto_common-1.39.1.tar.gz", hash = "sha256:763370d4737a59741c89a67b50f9e39271639ee4afc999dadfe768541c027464", size = 20409, upload-time = "2025-12-11T13:32:40.885Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/02/ffc3e143d89a27ac21fd557365b98bd0653b98de8a101151d5805b5d4c33/opentelemetry_exporter_otlp_proto_common-1.39.1-py3-none-any.whl", hash = "sha256:08f8a5862d64cc3435105686d0216c1365dc5701f86844a8cd56597d0c764fde", size = 18366, upload-time = "2025-12-11T13:32:20.2Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-proto-http"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "googleapis-common-protos" },
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-otlp-proto-common" },
+    { name = "opentelemetry-proto" },
+    { name = "opentelemetry-sdk" },
+    { name = "requests" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/80/04/2a08fa9c0214ae38880df01e8bfae12b067ec0793446578575e5080d6545/opentelemetry_exporter_otlp_proto_http-1.39.1.tar.gz", hash = "sha256:31bdab9745c709ce90a49a0624c2bd445d31a28ba34275951a6a362d16a0b9cb", size = 17288, upload-time = "2025-12-11T13:32:42.029Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/f1/b27d3e2e003cd9a3592c43d099d2ed8d0a947c15281bf8463a256db0b46c/opentelemetry_exporter_otlp_proto_http-1.39.1-py3-none-any.whl", hash = "sha256:d9f5207183dd752a412c4cd564ca8875ececba13be6e9c6c370ffb752fd59985", size = 19641, upload-time = "2025-12-11T13:32:22.248Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/41/0f/7e6b713ac117c1f5e4e3300748af699b9902a2e5e34c9cf443dde25a01fa/opentelemetry_instrumentation-0.60b1.tar.gz", hash = "sha256:57ddc7974c6eb35865af0426d1a17132b88b2ed8586897fee187fd5b8944bd6a", size = 31706, upload-time = "2025-12-11T13:36:42.515Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/d2/6788e83c5c86a2690101681aeef27eeb2a6bf22df52d3f263a22cee20915/opentelemetry_instrumentation-0.60b1-py3-none-any.whl", hash = "sha256:04480db952b48fb1ed0073f822f0ee26012b7be7c3eac1a3793122737c78632d", size = 33096, upload-time = "2025-12-11T13:35:33.067Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-httpx"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/86/08/11208bcfcab4fc2023252c3f322aa397fd9ad948355fea60f5fc98648603/opentelemetry_instrumentation_httpx-0.60b1.tar.gz", hash = "sha256:a506ebaf28c60112cbe70ad4f0338f8603f148938cb7b6794ce1051cd2b270ae", size = 20611, upload-time = "2025-12-11T13:37:01.661Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/59/b98e84eebf745ffc75397eaad4763795bff8a30cbf2373a50ed4e70646c5/opentelemetry_instrumentation_httpx-0.60b1-py3-none-any.whl", hash = "sha256:f37636dd742ad2af83d896ba69601ed28da51fa4e25d1ab62fde89ce413e275b", size = 15701, upload-time = "2025-12-11T13:36:04.56Z" },
+]
+
+[[package]]
+name = "opentelemetry-proto"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "protobuf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/1d/f25d76d8260c156c40c97c9ed4511ec0f9ce353f8108ca6e7561f82a06b2/opentelemetry_proto-1.39.1.tar.gz", hash = "sha256:6c8e05144fc0d3ed4d22c2289c6b126e03bcd0e6a7da0f16cedd2e1c2772e2c8", size = 46152, upload-time = "2025-12-11T13:32:48.681Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/95/b40c96a7b5203005a0b03d8ce8cd212ff23f1793d5ba289c87a097571b18/opentelemetry_proto-1.39.1-py3-none-any.whl", hash = "sha256:22cdc78efd3b3765d09e68bfbd010d4fc254c9818afd0b6b423387d9dee46007", size = 72535, upload-time = "2025-12-11T13:32:33.866Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.39.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/fb/c76080c9ba07e1e8235d24cdcc4d125ef7aa3edf23eb4e497c2e50889adc/opentelemetry_sdk-1.39.1.tar.gz", hash = "sha256:cf4d4563caf7bff906c9f7967e2be22d0d6b349b908be0d90fb21c8e9c995cc6", size = 171460, upload-time = "2025-12-11T13:32:49.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7c/98/e91cf858f203d86f4eccdf763dcf01cf03f1dae80c3750f7e635bfa206b6/opentelemetry_sdk-1.39.1-py3-none-any.whl", hash = "sha256:4d5482c478513ecb0a5d938dcc61394e647066e0cc2676bee9f3af3f3f45f01c", size = 132565, upload-time = "2025-12-11T13:32:35.069Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/91/df/553f93ed38bf22f4b999d9be9c185adb558982214f33eae539d3b5cd0858/opentelemetry_semantic_conventions-0.60b1.tar.gz", hash = "sha256:87c228b5a0669b748c76d76df6c364c369c28f1c465e50f661e39737e84bc953", size = 137935, upload-time = "2025-12-11T13:32:50.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/5e/5958555e09635d09b75de3c4f8b9cae7335ca545d77392ffe7331534c402/opentelemetry_semantic_conventions-0.60b1-py3-none-any.whl", hash = "sha256:9fa8c8b0c110da289809292b0591220d3a7b53c1526a23021e977d68597893fb", size = 219982, upload-time = "2025-12-11T13:32:36.955Z" },
+]
+
+[[package]]
+name = "opentelemetry-util-http"
+version = "0.60b1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/50/fc/c47bb04a1d8a941a4061307e1eddfa331ed4d0ab13d8a9781e6db256940a/opentelemetry_util_http-0.60b1.tar.gz", hash = "sha256:0d97152ca8c8a41ced7172d29d3622a219317f74ae6bb3027cfbdcf22c3cc0d6", size = 11053, upload-time = "2025-12-11T13:37:25.115Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/5c/d3f1733665f7cd582ef0842fb1d2ed0bc1fba10875160593342d22bba375/opentelemetry_util_http-0.60b1-py3-none-any.whl", hash = "sha256:66381ba28550c91bee14dcba8979ace443444af1ed609226634596b4b0faf199", size = 8947, upload-time = "2025-12-11T13:36:37.151Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "pathable"
+version = "0.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/55/b748445cb4ea6b125626f15379be7c96d1035d4fa3e8fee362fa92298abf/pathable-0.5.0.tar.gz", hash = "sha256:d81938348a1cacb525e7c75166270644782c0fb9c8cecc16be033e71427e0ef1", size = 16655, upload-time = "2026-02-20T08:47:00.748Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/96/5a770e5c461462575474468e5af931cff9de036e7c2b4fea23c1c58d2cbe/pathable-0.5.0-py3-none-any.whl", hash = "sha256:646e3d09491a6351a0c82632a09c02cdf70a252e73196b36d8a15ba0a114f0a6", size = 16867, upload-time = "2026-02-20T08:46:59.536Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.9.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.52"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" },
+    { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" },
+    { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" },
+    { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" },
+    { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" },
+    { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" },
+    { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" },
+    { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" },
+    { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" },
+    { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" },
+    { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" },
+    { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "6.33.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/9f/2f509339e89cfa6f6a4c4ff50438db9ca488dec341f7e454adad60150b00/protobuf-6.33.6-cp310-abi3-win32.whl", hash = "sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3", size = 425739, upload-time = "2026-03-18T19:04:48.373Z" },
+    { url = "https://files.pythonhosted.org/packages/76/5d/683efcd4798e0030c1bab27374fd13a89f7c2515fb1f3123efdfaa5eab57/protobuf-6.33.6-cp310-abi3-win_amd64.whl", hash = "sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326", size = 437089, upload-time = "2026-03-18T19:04:50.381Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/01/a3c3ed5cd186f39e7880f8303cc51385a198a81469d53d0fdecf1f64d929/protobuf-6.33.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a", size = 427737, upload-time = "2026-03-18T19:04:51.866Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" },
+    { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" },
+    { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" },
+    { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" },
+    { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" },
+    { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+    { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+    { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
+]
+
+[[package]]
+name = "py-key-value-aio"
+version = "0.4.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beartype" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/3c/0397c072a38d4bc580994b42e0c90c5f44f679303489e4376289534735e5/py_key_value_aio-0.4.4.tar.gz", hash = "sha256:e3012e6243ed7cc09bb05457bd4d03b1ba5c2b1ca8700096b3927db79ffbbe55", size = 92300, upload-time = "2026-02-16T21:21:43.245Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/69/f1b537ee70b7def42d63124a539ed3026a11a3ffc3086947a1ca6e861868/py_key_value_aio-0.4.4-py3-none-any.whl", hash = "sha256:18e17564ecae61b987f909fc2cd41ee2012c84b4b1dcb8c055cf8b4bc1bf3f5d", size = 152291, upload-time = "2026-02-16T21:21:44.241Z" },
+]
+
+[package.optional-dependencies]
+filetree = [
+    { name = "aiofile" },
+    { name = "anyio" },
+]
+keyring = [
+    { name = "keyring" },
+]
+memory = [
+    { name = "cachetools" },
+]
+
+[[package]]
+name = "pyasn1"
+version = "0.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/5f/6583902b6f79b399c9c40674ac384fd9cd77805f9e6205075f828ef11fb2/pyasn1-0.6.3.tar.gz", hash = "sha256:697a8ecd6d98891189184ca1fa05d1bb00e2f84b5977c481452050549c8a72cf", size = 148685, upload-time = "2026-03-17T01:06:53.382Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/a0/7d793dce3fa811fe047d6ae2431c672364b462850c6235ae306c0efd025f/pyasn1-0.6.3-py3-none-any.whl", hash = "sha256:a80184d120f0864a52a073acc6fc642847d0be408e7c7252f31390c0f4eadcde", size = 83997, upload-time = "2026-03-17T01:06:52.036Z" },
+]
+
+[[package]]
+name = "pyasn1-modules"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyasn1" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload-time = "2025-03-28T02:41:22.17Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259, upload-time = "2025-03-28T02:41:19.028Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[package.optional-dependencies]
+email = [
+    { name = "email-validator" },
+]
+
+[[package]]
+name = "pydantic-ai"
+version = "1.80.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic-ai-slim", extra = ["ag-ui", "anthropic", "bedrock", "cli", "cohere", "evals", "fastmcp", "google", "groq", "huggingface", "logfire", "mcp", "mistral", "openai", "retries", "spec", "temporal", "ui", "vertexai", "xai"] },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/fa/74ebb63cab77331fd98124e6665bff1634415a739a5f4aba077ce34f0e81/pydantic_ai-1.80.0.tar.gz", hash = "sha256:93aa897fac720cd9e11b4f47b0c456649cc72f4b65e575eddfd9adbecc200b81", size = 12793, upload-time = "2026-04-10T23:31:17.844Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/9a/6d65ea560f8e84f57cf5cf7f5b611d48bd5d1869120bc7fcc3b40aed0556/pydantic_ai-1.80.0-py3-none-any.whl", hash = "sha256:71d0117a7c55116c00d7dfdc973f0bead056709608b251f83a884821341177ee", size = 7549, upload-time = "2026-04-10T23:31:09.674Z" },
+]
+
+[[package]]
+name = "pydantic-ai-slim"
+version = "1.80.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "genai-prices" },
+    { name = "griffelib" },
+    { name = "httpx" },
+    { name = "opentelemetry-api" },
+    { name = "pydantic" },
+    { name = "pydantic-graph" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/27/aa309951a8973a8525fdf9e45b49960105bc78ebc8dba48366c2853538ae/pydantic_ai_slim-1.80.0.tar.gz", hash = "sha256:034f7f910dfce5d82528c74a717a99065ae548390f0b906165972cd13a87d2cf", size = 549153, upload-time = "2026-04-10T23:31:19.862Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/23/bf/ef273265ef3530cf432fd6d0014ceed57d1cc5b1550fd975bc91152633c8/pydantic_ai_slim-1.80.0-py3-none-any.whl", hash = "sha256:160ad31f522c3d091f3ce32b478d26034c05b6c2c84798a4c8b191c7f9f94bee", size = 703157, upload-time = "2026-04-10T23:31:12Z" },
+]
+
+[package.optional-dependencies]
+ag-ui = [
+    { name = "ag-ui-protocol" },
+    { name = "starlette" },
+]
+anthropic = [
+    { name = "anthropic" },
+]
+bedrock = [
+    { name = "boto3" },
+]
+cli = [
+    { name = "argcomplete" },
+    { name = "prompt-toolkit" },
+    { name = "pyperclip" },
+    { name = "pyyaml" },
+    { name = "rich" },
+]
+cohere = [
+    { name = "cohere", marker = "sys_platform != 'emscripten'" },
+]
+evals = [
+    { name = "pydantic-evals" },
+]
+fastmcp = [
+    { name = "fastmcp" },
+]
+google = [
+    { name = "google-genai" },
+]
+groq = [
+    { name = "groq" },
+]
+huggingface = [
+    { name = "huggingface-hub" },
+]
+logfire = [
+    { name = "logfire", extra = ["httpx"] },
+]
+mcp = [
+    { name = "mcp" },
+]
+mistral = [
+    { name = "mistralai" },
+]
+openai = [
+    { name = "openai" },
+    { name = "tiktoken" },
+]
+retries = [
+    { name = "tenacity" },
+]
+spec = [
+    { name = "pydantic-handlebars" },
+    { name = "pyyaml" },
+]
+temporal = [
+    { name = "temporalio" },
+]
+ui = [
+    { name = "starlette" },
+]
+vertexai = [
+    { name = "google-auth" },
+    { name = "requests" },
+]
+xai = [
+    { name = "xai-sdk" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+]
+
+[[package]]
+name = "pydantic-evals"
+version = "1.80.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "logfire-api" },
+    { name = "pydantic" },
+    { name = "pydantic-ai-slim" },
+    { name = "pyyaml" },
+    { name = "rich" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8c/c3/49c0f1221321a56540b3fd7251a20d9e5a2de512f170afd9c6d08fe5b24c/pydantic_evals-1.80.0.tar.gz", hash = "sha256:03ee78212069638a9abe107997c02adbe7de01a2769c2a3aa1ae37e40c4f2b36", size = 65791, upload-time = "2026-04-10T23:31:21.321Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/28/8480d2e53728a891e1157f6c741a7f2ec27da06b56936d5c6e1f64af0e51/pydantic_evals-1.80.0-py3-none-any.whl", hash = "sha256:1af302e312aa39a7fc20c14acfaea35283861d933a03473d43d858e3c07ac8ef", size = 77711, upload-time = "2026-04-10T23:31:13.937Z" },
+]
+
+[[package]]
+name = "pydantic-graph"
+version = "1.80.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "logfire-api" },
+    { name = "pydantic" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/7b/03a8791e4916cb0f841fcd77ef6b6bf504419bf03d1c16e4ef80bfd553ad/pydantic_graph-1.80.0.tar.gz", hash = "sha256:94b8c2dd20730ce3cd0fa544ca9c31011a7bb0c5b9f5ca1dade6a6bed7719e8c", size = 59243, upload-time = "2026-04-10T23:31:22.504Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/12/483b7402d302021ff8537a746eebf018f4e0bb5892c7bef769ab968e03c1/pydantic_graph-1.80.0-py3-none-any.whl", hash = "sha256:60315c2042597d0377689ad48e9439760ec75d4ccda78830d2890ce9c94c6d84", size = 73065, upload-time = "2026-04-10T23:31:15.382Z" },
+]
+
+[[package]]
+name = "pydantic-handlebars"
+version = "0.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/16/d41768bd3fd77e6250c20be11a3e68fee5fff07c3356455e6708f6a60f2a/pydantic_handlebars-0.1.0.tar.gz", hash = "sha256:1931c54946add1b5e3796c9bf6a005ed7662cef0109bb05c352f0b3d031a1260", size = 159826, upload-time = "2026-03-01T20:00:17.497Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/5f/86b1630be61bdebf253c2f953a6c3f073ec21bb0725565ea3896802e1ca3/pydantic_handlebars-0.1.0-py3-none-any.whl", hash = "sha256:8a436fe8bc607295eb04bec58bd6e2c9498c9e069c557ff0b505e3d568c783bc", size = 40890, upload-time = "2026-03-01T20:00:16.106Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" },
+]
+
+[package.optional-dependencies]
+crypto = [
+    { name = "cryptography" },
+]
+
+[[package]]
+name = "pyperclip"
+version = "1.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/52/d87eba7cb129b81563019d1679026e7a112ef76855d6159d24754dbd2a51/pyperclip-1.11.0.tar.gz", hash = "sha256:244035963e4428530d9e3a6101a1ef97209c6825edab1567beac148ccc1db1b6", size = 12185, upload-time = "2025-09-26T14:40:37.245Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/80/fc9d01d5ed37ba4c42ca2b55b4339ae6e200b456be3a1aaddf4a9fa99b8c/pyperclip-1.11.0-py3-none-any.whl", hash = "sha256:299403e9ff44581cb9ba2ffeed69c7aa96a008622ad0c46cb575ca75b5b84273", size = 11063, upload-time = "2025-09-26T14:40:36.069Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "python-multipart"
+version = "0.0.26"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/88/71/b145a380824a960ebd60e1014256dbb7d2253f2316ff2d73dfd8928ec2c3/python_multipart-0.0.26.tar.gz", hash = "sha256:08fadc45918cd615e26846437f50c5d6d23304da32c341f289a617127b081f17", size = 43501, upload-time = "2026-04-10T14:09:59.473Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/22/f1925cdda983ab66fc8ec6ec8014b959262747e58bdca26a4e3d1da29d56/python_multipart-0.0.26-py3-none-any.whl", hash = "sha256:c0b169f8c4484c13b0dcf2ef0ec3a4adb255c4b7d18d8e420477d2b1dd03f185", size = 28847, upload-time = "2026-04-10T14:09:58.131Z" },
+]
+
+[[package]]
+name = "pywin32"
+version = "311"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" },
+    { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" },
+    { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" },
+]
+
+[[package]]
+name = "pywin32-ctypes"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
+[[package]]
+name = "regex"
+version = "2026.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cb/0e/3a246dbf05666918bd3664d9d787f84a9108f6f43cc953a077e4a7dfdb7e/regex-2026.4.4.tar.gz", hash = "sha256:e08270659717f6973523ce3afbafa53515c4dc5dcad637dc215b6fd50f689423", size = 416000, upload-time = "2026-04-03T20:56:28.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/28/b972a4d3df61e1d7bcf1b59fdb3cddef22f88b6be43f161bb41ebc0e4081/regex-2026.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:c07ab8794fa929e58d97a0e1796b8b76f70943fa39df225ac9964615cf1f9d52", size = 490434, upload-time = "2026-04-03T20:53:40.219Z" },
+    { url = "https://files.pythonhosted.org/packages/84/20/30041446cf6dc3e0eab344fc62770e84c23b6b68a3b657821f9f80cb69b4/regex-2026.4.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c785939dc023a1ce4ec09599c032cc9933d258a998d16ca6f2b596c010940eb", size = 292061, upload-time = "2026-04-03T20:53:41.862Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c8/3baa06d75c98c46d4cc4262b71fd2edb9062b5665e868bca57859dadf93a/regex-2026.4.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1b1ce5c81c9114f1ce2f9288a51a8fd3aeea33a0cc440c415bf02da323aa0a76", size = 289628, upload-time = "2026-04-03T20:53:43.701Z" },
+    { url = "https://files.pythonhosted.org/packages/31/87/3accf55634caad8c0acab23f5135ef7d4a21c39f28c55c816ae012931408/regex-2026.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:760ef21c17d8e6a4fe8cf406a97cf2806a4df93416ccc82fc98d25b1c20425be", size = 796651, upload-time = "2026-04-03T20:53:45.379Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/0c/aaa2c83f34efedbf06f61cb1942c25f6cf1ee3b200f832c4d05f28306c2e/regex-2026.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7088fcdcb604a4417c208e2169715800d28838fefd7455fbe40416231d1d47c1", size = 865916, upload-time = "2026-04-03T20:53:47.064Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/f6/8c6924c865124643e8f37823eca845dc27ac509b2ee58123685e71cd0279/regex-2026.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:07edca1ba687998968f7db5bc355288d0c6505caa7374f013d27356d93976d13", size = 912287, upload-time = "2026-04-03T20:53:49.422Z" },
+    { url = "https://files.pythonhosted.org/packages/11/0e/a9f6f81013e0deaf559b25711623864970fe6a098314e374ccb1540a4152/regex-2026.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:993f657a7c1c6ec51b5e0ba97c9817d06b84ea5fa8d82e43b9405de0defdc2b9", size = 801126, upload-time = "2026-04-03T20:53:51.096Z" },
+    { url = "https://files.pythonhosted.org/packages/71/61/3a0cc8af2dc0c8deb48e644dd2521f173f7e6513c6e195aad9aa8dd77ac5/regex-2026.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2b69102a743e7569ebee67e634a69c4cb7e59d6fa2e1aa7d3bdbf3f61435f62d", size = 776788, upload-time = "2026-04-03T20:53:52.889Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0b/8bb9cbf21ef7dee58e49b0fdb066a7aded146c823202e16494a36777594f/regex-2026.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dac006c8b6dda72d86ea3d1333d45147de79a3a3f26f10c1cf9287ca4ca0ac3", size = 785184, upload-time = "2026-04-03T20:53:55.627Z" },
+    { url = "https://files.pythonhosted.org/packages/99/c2/d3e80e8137b25ee06c92627de4e4d98b94830e02b3e6f81f3d2e3f504cf5/regex-2026.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:50a766ee2010d504554bfb5f578ed2e066898aa26411d57e6296230627cdefa0", size = 859913, upload-time = "2026-04-03T20:53:57.249Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/9d5d876157d969c804622456ef250017ac7a8f83e0e14f903b9e6df5ce95/regex-2026.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9e2f5217648f68e3028c823df58663587c1507a5ba8419f4fdfc8a461be76043", size = 765732, upload-time = "2026-04-03T20:53:59.428Z" },
+    { url = "https://files.pythonhosted.org/packages/82/80/b568935b4421388561c8ed42aff77247285d3ae3bb2a6ca22af63bae805e/regex-2026.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:39d8de85a08e32632974151ba59c6e9140646dcc36c80423962b1c5c0a92e244", size = 852152, upload-time = "2026-04-03T20:54:01.505Z" },
+    { url = "https://files.pythonhosted.org/packages/39/29/f0f81217e21cd998245da047405366385d5c6072048038a3d33b37a79dc0/regex-2026.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:55d9304e0e7178dfb1e106c33edf834097ddf4a890e2f676f6c5118f84390f73", size = 789076, upload-time = "2026-04-03T20:54:03.323Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1d/1d957a61976ab9d4e767dd4f9d04b66cc0c41c5e36cf40e2d43688b5ae6f/regex-2026.4.4-cp312-cp312-win32.whl", hash = "sha256:04bb679bc0bde8a7bfb71e991493d47314e7b98380b083df2447cda4b6edb60f", size = 266700, upload-time = "2026-04-03T20:54:05.639Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/5c/bf575d396aeb58ea13b06ef2adf624f65b70fafef6950a80fc3da9cae3bc/regex-2026.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:db0ac18435a40a2543dbb3d21e161a6c78e33e8159bd2e009343d224bb03bb1b", size = 277768, upload-time = "2026-04-03T20:54:07.312Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/27/049df16ec6a6828ccd72add3c7f54b4df029669bea8e9817df6fff58be90/regex-2026.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:4ce255cc05c1947a12989c6db801c96461947adb7a59990f1360b5983fab4983", size = 270568, upload-time = "2026-04-03T20:54:09.484Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/83/c4373bc5f31f2cf4b66f9b7c31005bd87fe66f0dce17701f7db4ee79ee29/regex-2026.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:62f5519042c101762509b1d717b45a69c0139d60414b3c604b81328c01bd1943", size = 490273, upload-time = "2026-04-03T20:54:11.202Z" },
+    { url = "https://files.pythonhosted.org/packages/46/f8/fe62afbcc3cf4ad4ac9adeaafd98aa747869ae12d3e8e2ac293d0593c435/regex-2026.4.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3790ba9fb5dd76715a7afe34dbe603ba03f8820764b1dc929dd08106214ed031", size = 291954, upload-time = "2026-04-03T20:54:13.412Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/92/4712b9fe6a33d232eeb1c189484b80c6c4b8422b90e766e1195d6e758207/regex-2026.4.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8fae3c6e795d7678963f2170152b0d892cf6aee9ee8afc8c45e6be38d5107fe7", size = 289487, upload-time = "2026-04-03T20:54:15.824Z" },
+    { url = "https://files.pythonhosted.org/packages/88/2c/f83b93f85e01168f1070f045a42d4c937b69fdb8dd7ae82d307253f7e36e/regex-2026.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:298c3ec2d53225b3bf91142eb9691025bab610e0c0c51592dde149db679b3d17", size = 796646, upload-time = "2026-04-03T20:54:18.229Z" },
+    { url = "https://files.pythonhosted.org/packages/df/55/61a2e17bf0c4dc57e11caf8dd11771280d8aaa361785f9e3bc40d653f4a7/regex-2026.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e9638791082eaf5b3ac112c587518ee78e083a11c4b28012d8fe2a0f536dfb17", size = 865904, upload-time = "2026-04-03T20:54:20.019Z" },
+    { url = "https://files.pythonhosted.org/packages/45/32/1ac8ed1b5a346b5993a3d256abe0a0f03b0b73c8cc88d928537368ac65b6/regex-2026.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ae3e764bd4c5ff55035dc82a8d49acceb42a5298edf6eb2fc4d328ee5dd7afae", size = 912304, upload-time = "2026-04-03T20:54:22.403Z" },
+    { url = "https://files.pythonhosted.org/packages/26/47/2ee5c613ab546f0eddebf9905d23e07beb933416b1246c2d8791d01979b4/regex-2026.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ffa81f81b80047ba89a3c69ae6a0f78d06f4a42ce5126b0eb2a0a10ad44e0b2e", size = 801126, upload-time = "2026-04-03T20:54:24.308Z" },
+    { url = "https://files.pythonhosted.org/packages/75/cd/41dacd129ca9fd20bd7d02f83e0fad83e034ac8a084ec369c90f55ef37e2/regex-2026.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f56ebf9d70305307a707911b88469213630aba821e77de7d603f9d2f0730687d", size = 776772, upload-time = "2026-04-03T20:54:26.319Z" },
+    { url = "https://files.pythonhosted.org/packages/89/6d/5af0b588174cb5f46041fa7dd64d3fd5cd2fe51f18766703d1edc387f324/regex-2026.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:773d1dfd652bbffb09336abf890bfd64785c7463716bf766d0eb3bc19c8b7f27", size = 785228, upload-time = "2026-04-03T20:54:28.387Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/3b/f5a72b7045bd59575fc33bf1345f156fcfd5a8484aea6ad84b12c5a82114/regex-2026.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:d51d20befd5275d092cdffba57ded05f3c436317ee56466c8928ac32d960edaf", size = 860032, upload-time = "2026-04-03T20:54:30.641Z" },
+    { url = "https://files.pythonhosted.org/packages/39/a4/72a317003d6fcd7a573584a85f59f525dfe8f67e355ca74eb6b53d66a5e2/regex-2026.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:0a51cdb3c1e9161154f976cb2bef9894bc063ac82f31b733087ffb8e880137d0", size = 765714, upload-time = "2026-04-03T20:54:32.789Z" },
+    { url = "https://files.pythonhosted.org/packages/25/1e/5672e16f34dbbcb2560cc7e6a2fbb26dfa8b270711e730101da4423d3973/regex-2026.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ae5266a82596114e41fb5302140e9630204c1b5f325c770bec654b95dd54b0aa", size = 852078, upload-time = "2026-04-03T20:54:34.546Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/0d/c813f0af7c6cc7ed7b9558bac2e5120b60ad0fa48f813e4d4bd55446f214/regex-2026.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c882cd92ec68585e9c1cf36c447ec846c0d94edd706fe59e0c198e65822fd23b", size = 789181, upload-time = "2026-04-03T20:54:36.642Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/6d/a344608d1adbd2a95090ddd906cec09a11be0e6517e878d02a5123e0917f/regex-2026.4.4-cp313-cp313-win32.whl", hash = "sha256:05568c4fbf3cb4fa9e28e3af198c40d3237cf6041608a9022285fe567ec3ad62", size = 266690, upload-time = "2026-04-03T20:54:38.343Z" },
+    { url = "https://files.pythonhosted.org/packages/31/07/54049f89b46235ca6f45cd6c88668a7050e77d4a15555e47dd40fde75263/regex-2026.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:3384df51ed52db0bea967e21458ab0a414f67cdddfd94401688274e55147bb81", size = 277733, upload-time = "2026-04-03T20:54:40.11Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/21/61366a8e20f4d43fb597708cac7f0e2baadb491ecc9549b4980b2be27d16/regex-2026.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:acd38177bd2c8e69a411d6521760806042e244d0ef94e2dd03ecdaa8a3c99427", size = 270565, upload-time = "2026-04-03T20:54:41.883Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/1e/3a2b9672433bef02f5d39aa1143ca2c08f311c1d041c464a42be9ae648dc/regex-2026.4.4-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f94a11a9d05afcfcfa640e096319720a19cc0c9f7768e1a61fceee6a3afc6c7c", size = 494126, upload-time = "2026-04-03T20:54:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/4b/c132a4f4fe18ad3340d89fcb56235132b69559136036b845be3c073142ed/regex-2026.4.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:36bcb9d6d1307ab629edc553775baada2aefa5c50ccc0215fbfd2afcfff43141", size = 293882, upload-time = "2026-04-03T20:54:45.41Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/5f/eaa38092ce7a023656280f2341dbbd4ad5f05d780a70abba7bb4f4bea54c/regex-2026.4.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:261c015b3e2ed0919157046d768774ecde57f03d8fa4ba78d29793447f70e717", size = 292334, upload-time = "2026-04-03T20:54:47.051Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/f6/dd38146af1392dac33db7074ab331cec23cced3759167735c42c5460a243/regex-2026.4.4-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c228cf65b4a54583763645dcd73819b3b381ca8b4bb1b349dee1c135f4112c07", size = 811691, upload-time = "2026-04-03T20:54:49.074Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f0/dc54c2e69f5eeec50601054998ec3690d5344277e782bd717e49867c1d29/regex-2026.4.4-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dd2630faeb6876fb0c287f664d93ddce4d50cd46c6e88e60378c05c9047e08ca", size = 871227, upload-time = "2026-04-03T20:54:51.035Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/af/cb16bd5dc61621e27df919a4449bbb7e5a1034c34d307e0a706e9cc0f3e3/regex-2026.4.4-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6a50ab11b7779b849472337191f3a043e27e17f71555f98d0092fa6d73364520", size = 917435, upload-time = "2026-04-03T20:54:52.994Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/71/8b260897f22996b666edd9402861668f45a2ca259f665ac029e6104a2d7d/regex-2026.4.4-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0734f63afe785138549fbe822a8cfeaccd1bae814c5057cc0ed5b9f2de4fc883", size = 816358, upload-time = "2026-04-03T20:54:54.884Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/60/775f7f72a510ef238254906c2f3d737fc80b16ca85f07d20e318d2eea894/regex-2026.4.4-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c4ee50606cb1967db7e523224e05f32089101945f859928e65657a2cbb3d278b", size = 785549, upload-time = "2026-04-03T20:54:57.01Z" },
+    { url = "https://files.pythonhosted.org/packages/58/42/34d289b3627c03cf381e44da534a0021664188fa49ba41513da0b4ec6776/regex-2026.4.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6c1818f37be3ca02dcb76d63f2c7aaba4b0dc171b579796c6fbe00148dfec6b1", size = 801364, upload-time = "2026-04-03T20:54:58.981Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/20/f6ecf319b382a8f1ab529e898b222c3f30600fcede7834733c26279e7465/regex-2026.4.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f5bfc2741d150d0be3e4a0401a5c22b06e60acb9aa4daa46d9e79a6dcd0f135b", size = 866221, upload-time = "2026-04-03T20:55:00.88Z" },
+    { url = "https://files.pythonhosted.org/packages/92/6a/9f16d3609d549bd96d7a0b2aee1625d7512ba6a03efc01652149ef88e74d/regex-2026.4.4-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:504ffa8a03609a087cad81277a629b6ce884b51a24bd388a7980ad61748618ff", size = 772530, upload-time = "2026-04-03T20:55:03.213Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f6/aa9768bc96a4c361ac96419fbaf2dcdc33970bb813df3ba9b09d5d7b6d96/regex-2026.4.4-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:70aadc6ff12e4b444586e57fc30771f86253f9f0045b29016b9605b4be5f7dfb", size = 856989, upload-time = "2026-04-03T20:55:05.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/b4/c671db3556be2473ae3e4bb7a297c518d281452871501221251ea4ecba57/regex-2026.4.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f4f83781191007b6ef43b03debc35435f10cad9b96e16d147efe84a1d48bdde4", size = 803241, upload-time = "2026-04-03T20:55:07.162Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/5c/83e3b1d89fa4f6e5a1bc97b4abd4a9a97b3c1ac7854164f694f5f0ba98a0/regex-2026.4.4-cp313-cp313t-win32.whl", hash = "sha256:e014a797de43d1847df957c0a2a8e861d1c17547ee08467d1db2c370b7568baa", size = 269921, upload-time = "2026-04-03T20:55:09.62Z" },
+    { url = "https://files.pythonhosted.org/packages/28/07/077c387121f42cdb4d92b1301133c0d93b5709d096d1669ab847dda9fe2e/regex-2026.4.4-cp313-cp313t-win_amd64.whl", hash = "sha256:b15b88b0d52b179712632832c1d6e58e5774f93717849a41096880442da41ab0", size = 281240, upload-time = "2026-04-03T20:55:11.521Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/22/ead4a4abc7c59a4d882662aa292ca02c8b617f30b6e163bc1728879e9353/regex-2026.4.4-cp313-cp313t-win_arm64.whl", hash = "sha256:586b89cdadf7d67bf86ae3342a4dcd2b8d70a832d90c18a0ae955105caf34dbe", size = 272440, upload-time = "2026-04-03T20:55:13.365Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/f5/ed97c2dc47b5fbd4b73c0d7d75f9ebc8eca139f2bbef476bba35f28c0a77/regex-2026.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2da82d643fa698e5e5210e54af90181603d5853cf469f5eedf9bfc8f59b4b8c7", size = 490343, upload-time = "2026-04-03T20:55:15.241Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e9/de4828a7385ec166d673a5790ad06ac48cdaa98bc0960108dd4b9cc1aef7/regex-2026.4.4-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:54a1189ad9d9357760557c91103d5e421f0a2dabe68a5cdf9103d0dcf4e00752", size = 291909, upload-time = "2026-04-03T20:55:17.558Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/d6/5cfbfc97f3201a4d24b596a77957e092030dcc4205894bc035cedcfce62f/regex-2026.4.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:76d67d5afb1fe402d10a6403bae668d000441e2ab115191a804287d53b772951", size = 289692, upload-time = "2026-04-03T20:55:20.561Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/f2212d9fd56fe897e36d0110ba30ba2d247bd6410c5bd98499c7e5a1e1f2/regex-2026.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e7cd3e4ee8d80447a83bbc9ab0c8459781fa77087f856c3e740d7763be0df27f", size = 796979, upload-time = "2026-04-03T20:55:22.56Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/e3/a016c12675fbac988a60c7e1c16e67823ff0bc016beb27bd7a001dbdabc6/regex-2026.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e19e18c568d2866d8b6a6dfad823db86193503f90823a8f66689315ba28fbe8", size = 866744, upload-time = "2026-04-03T20:55:24.646Z" },
+    { url = "https://files.pythonhosted.org/packages/af/a4/0b90ca4cf17adc3cb43de80ec71018c37c88ad64987e8d0d481a95ca60b5/regex-2026.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7698a6f38730fd1385d390d1ed07bb13dce39aa616aca6a6d89bea178464b9a4", size = 911613, upload-time = "2026-04-03T20:55:27.033Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/3b/2b3dac0b82d41ab43aa87c6ecde63d71189d03fe8854b8ca455a315edac3/regex-2026.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:173a66f3651cdb761018078e2d9487f4cf971232c990035ec0eb1cdc6bf929a9", size = 800551, upload-time = "2026-04-03T20:55:29.532Z" },
+    { url = "https://files.pythonhosted.org/packages/25/fe/5365eb7aa0e753c4b5957815c321519ecab033c279c60e1b1ae2367fa810/regex-2026.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa7922bbb2cc84fa062d37723f199d4c0cd200245ce269c05db82d904db66b83", size = 776911, upload-time = "2026-04-03T20:55:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b3/7fb0072156bba065e3b778a7bc7b0a6328212be5dd6a86fd207e0c4f2dab/regex-2026.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:59f67cd0a0acaf0e564c20bbd7f767286f23e91e2572c5703bf3e56ea7557edb", size = 785751, upload-time = "2026-04-03T20:55:33.797Z" },
+    { url = "https://files.pythonhosted.org/packages/02/1a/9f83677eb699273e56e858f7bd95acdbee376d42f59e8bfca2fd80d79df3/regex-2026.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:475e50f3f73f73614f7cba5524d6de49dee269df00272a1b85e3d19f6d498465", size = 860484, upload-time = "2026-04-03T20:55:35.745Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/7a/93937507b61cfcff8b4c5857f1b452852b09f741daa9acae15c971d8554e/regex-2026.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:a1c0c7d67b64d85ac2e1879923bad2f08a08f3004055f2f406ef73c850114bd4", size = 765939, upload-time = "2026-04-03T20:55:37.972Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ea/81a7f968a351c6552b1670ead861e2a385be730ee28402233020c67f9e0f/regex-2026.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:1371c2ccbb744d66ee63631cc9ca12aa233d5749972626b68fe1a649dd98e566", size = 851417, upload-time = "2026-04-03T20:55:39.92Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/7e/323c18ce4b5b8f44517a36342961a0306e931e499febbd876bb149d900f0/regex-2026.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:59968142787042db793348a3f5b918cf24ced1f23247328530e063f89c128a95", size = 789056, upload-time = "2026-04-03T20:55:42.303Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/af/e7510f9b11b1913b0cd44eddb784b2d650b2af6515bfce4cffcc5bfd1d38/regex-2026.4.4-cp314-cp314-win32.whl", hash = "sha256:59efe72d37fd5a91e373e5146f187f921f365f4abc1249a5ab446a60f30dd5f8", size = 272130, upload-time = "2026-04-03T20:55:44.995Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/51/57dae534c915e2d3a21490e88836fa2ae79dde3b66255ecc0c0a155d2c10/regex-2026.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:e0aab3ff447845049d676827d2ff714aab4f73f340e155b7de7458cf53baa5a4", size = 280992, upload-time = "2026-04-03T20:55:47.316Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5e/abaf9f4c3792e34edb1434f06717fae2b07888d85cb5cec29f9204931bf8/regex-2026.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:a7a5bb6aa0cf62208bb4fa079b0c756734f8ad0e333b425732e8609bd51ee22f", size = 273563, upload-time = "2026-04-03T20:55:49.273Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/06/35da85f9f217b9538b99cbb170738993bcc3b23784322decb77619f11502/regex-2026.4.4-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:97850d0638391bdc7d35dc1c1039974dcb921eaafa8cc935ae4d7f272b1d60b3", size = 494191, upload-time = "2026-04-03T20:55:51.258Z" },
+    { url = "https://files.pythonhosted.org/packages/54/5b/1bc35f479eef8285c4baf88d8c002023efdeebb7b44a8735b36195486ae7/regex-2026.4.4-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ee7337f88f2a580679f7bbfe69dc86c043954f9f9c541012f49abc554a962f2e", size = 293877, upload-time = "2026-04-03T20:55:53.214Z" },
+    { url = "https://files.pythonhosted.org/packages/39/5b/f53b9ad17480b3ddd14c90da04bfb55ac6894b129e5dea87bcaf7d00e336/regex-2026.4.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7429f4e6192c11d659900c0648ba8776243bf396ab95558b8c51a345afeddde6", size = 292410, upload-time = "2026-04-03T20:55:55.736Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/56/52377f59f60a7c51aa4161eecf0b6032c20b461805aca051250da435ffc9/regex-2026.4.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4f10fbd5dd13dcf4265b4cc07d69ca70280742870c97ae10093e3d66000359", size = 811831, upload-time = "2026-04-03T20:55:57.802Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/63/8026310bf066f702a9c361f83a8c9658f3fe4edb349f9c1e5d5273b7c40c/regex-2026.4.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a152560af4f9742b96f3827090f866eeec5becd4765c8e0d3473d9d280e76a5a", size = 871199, upload-time = "2026-04-03T20:56:00.333Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9f/a514bbb00a466dbb506d43f187a04047f7be1505f10a9a15615ead5080ee/regex-2026.4.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54170b3e95339f415d54651f97df3bff7434a663912f9358237941bbf9143f55", size = 917649, upload-time = "2026-04-03T20:56:02.445Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/6b/8399f68dd41a2030218839b9b18360d79b86d22b9fab5ef477c7f23ca67c/regex-2026.4.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:07f190d65f5a72dcb9cf7106bfc3d21e7a49dd2879eda2207b683f32165e4d99", size = 816388, upload-time = "2026-04-03T20:56:04.595Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/9c/103963f47c24339a483b05edd568594c2be486188f688c0170fd504b2948/regex-2026.4.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9a2741ce5a29d3c84b0b94261ba630ab459a1b847a0d6beca7d62d188175c790", size = 785746, upload-time = "2026-04-03T20:56:07.13Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ee/7f6054c0dec0cee3463c304405e4ff42e27cff05bf36fcb34be549ab17bd/regex-2026.4.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b26c30df3a28fd9793113dac7385a4deb7294a06c0f760dd2b008bd49a9139bc", size = 801483, upload-time = "2026-04-03T20:56:09.365Z" },
+    { url = "https://files.pythonhosted.org/packages/30/c2/51d3d941cf6070dc00c3338ecf138615fc3cce0421c3df6abe97a08af61a/regex-2026.4.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:421439d1bee44b19f4583ccf42670ca464ffb90e9fdc38d37f39d1ddd1e44f1f", size = 866331, upload-time = "2026-04-03T20:56:12.039Z" },
+    { url = "https://files.pythonhosted.org/packages/16/e8/76d50dcc122ac33927d939f350eebcfe3dbcbda96913e03433fc36de5e63/regex-2026.4.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:b40379b53ecbc747fd9bdf4a0ea14eb8188ca1bd0f54f78893a39024b28f4863", size = 772673, upload-time = "2026-04-03T20:56:14.558Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/6e/5f6bf75e20ea6873d05ba4ec78378c375cbe08cdec571c83fbb01606e563/regex-2026.4.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:08c55c13d2eef54f73eeadc33146fb0baaa49e7335eb1aff6ae1324bf0ddbe4a", size = 857146, upload-time = "2026-04-03T20:56:16.663Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/33/3c76d9962949e487ebba353a18e89399f292287204ac8f2f4cfc3a51c233/regex-2026.4.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9776b85f510062f5a75ef112afe5f494ef1635607bf1cc220c1391e9ac2f5e81", size = 803463, upload-time = "2026-04-03T20:56:18.923Z" },
+    { url = "https://files.pythonhosted.org/packages/19/eb/ef32dcd2cb69b69bc0c3e55205bce94a7def48d495358946bc42186dcccc/regex-2026.4.4-cp314-cp314t-win32.whl", hash = "sha256:385edaebde5db5be103577afc8699fea73a0e36a734ba24870be7ffa61119d74", size = 275709, upload-time = "2026-04-03T20:56:20.996Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/86/c291bf740945acbf35ed7dbebf8e2eea2f3f78041f6bd7cdab80cb274dc0/regex-2026.4.4-cp314-cp314t-win_amd64.whl", hash = "sha256:5d354b18839328927832e2fa5f7c95b7a3ccc39e7a681529e1685898e6436d45", size = 285622, upload-time = "2026-04-03T20:56:23.641Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/e7/ec846d560ae6a597115153c02ca6138a7877a1748b2072d9521c10a93e58/regex-2026.4.4-cp314-cp314t-win_arm64.whl", hash = "sha256:af0384cb01a33600c49505c27c6c57ab0b27bf84a74e28524c92ca897ebdac9d", size = 275773, upload-time = "2026-04-03T20:56:26.07Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.33.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/67/cae617f1351490c25a4b8ac3b8b63a4dda609295d8222bad12242dfdc629/rich-14.3.4.tar.gz", hash = "sha256:817e02727f2b25b40ef56f5aa2217f400c8489f79ca8f46ea2b70dd5e14558a9", size = 230524, upload-time = "2026-04-11T02:57:45.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/76/6d163cfac87b632216f71879e6b2cf17163f773ff59c00b5ff4900a80fa3/rich-14.3.4-py3-none-any.whl", hash = "sha256:07e7adb4690f68864777b1450859253bed81a99a31ac321ac1817b2313558952", size = 310480, upload-time = "2026-04-11T02:57:47.484Z" },
+]
+
+[[package]]
+name = "rich-rst"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "docutils" },
+    { name = "rich" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bc/6d/a506aaa4a9eaa945ed8ab2b7347859f53593864289853c5d6d62b77246e0/rich_rst-1.3.2.tar.gz", hash = "sha256:a1196fdddf1e364b02ec68a05e8ff8f6914fee10fbca2e6b6735f166bb0da8d4", size = 14936, upload-time = "2025-10-14T16:49:45.332Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/2f/b4530fbf948867702d0a3f27de4a6aab1d156f406d72852ab902c4d04de9/rich_rst-1.3.2-py3-none-any.whl", hash = "sha256:a99b4907cbe118cf9d18b0b44de272efa61f15117c61e39ebdc431baf5df722a", size = 12567, upload-time = "2025-10-14T16:49:42.953Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" },
+    { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" },
+    { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" },
+    { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" },
+    { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" },
+    { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" },
+    { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" },
+    { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" },
+    { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" },
+    { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" },
+    { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" },
+    { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" },
+    { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" },
+    { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" },
+    { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" },
+    { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" },
+    { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" },
+    { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" },
+    { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" },
+    { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" },
+    { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" },
+]
+
+[[package]]
+name = "s3transfer"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/05/04/74127fc843314818edfa81b5540e26dd537353b123a4edc563109d8f17dd/s3transfer-0.16.0.tar.gz", hash = "sha256:8e990f13268025792229cd52fa10cb7163744bf56e719e0b9cb925ab79abf920", size = 153827, upload-time = "2025-12-01T02:30:59.114Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/51/727abb13f44c1fcf6d145979e1535a35794db0f6e450a0cb46aa24732fe2/s3transfer-0.16.0-py3-none-any.whl", hash = "sha256:18e25d66fed509e3868dc1572b3f427ff947dd2c56f844a5bf09481ad3f3b2fe", size = 86830, upload-time = "2025-12-01T02:30:57.729Z" },
+]
+
+[[package]]
+name = "secretstorage"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cryptography" },
+    { name = "jeepney" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "sse-starlette"
+version = "3.3.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "starlette" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/26/8c/f9290339ef6d79badbc010f067cd769d6601ec11a57d78569c683fb4dd87/sse_starlette-3.3.4.tar.gz", hash = "sha256:aaf92fc067af8a5427192895ac028e947b484ac01edbc3caf00e7e7137c7bef1", size = 32427, upload-time = "2026-03-29T09:00:23.307Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/7f/3de5402f39890ac5660b86bcf5c03f9d855dad5c4ed764866d7b592b46fd/sse_starlette-3.3.4-py3-none-any.whl", hash = "sha256:84bb06e58939a8b38d8341f1bc9792f06c2b53f48c608dd207582b664fc8f3c1", size = 14330, upload-time = "2026-03-29T09:00:21.846Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/81/69/17425771797c36cded50b7fe44e850315d039f28b15901ab44839e70b593/starlette-1.0.0.tar.gz", hash = "sha256:6a4beaf1f81bb472fd19ea9b918b50dc3a77a6f2e190a12954b25e6ed5eea149", size = 2655289, upload-time = "2026-03-22T18:29:46.779Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/c9/584bc9651441b4ba60cc4d557d8a547b5aff901af35bda3a4ee30c819b82/starlette-1.0.0-py3-none-any.whl", hash = "sha256:d3ec55e0bb321692d275455ddfd3df75fff145d009685eb40dc91fc66b03d38b", size = 72651, upload-time = "2026-03-22T18:29:45.111Z" },
+]
+
+[[package]]
+name = "temporalio"
+version = "1.25.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nexus-rpc" },
+    { name = "protobuf" },
+    { name = "types-protobuf" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/9c/3782bab0bf11a40b550147c19a5d1a476c17405391751982408902d9f138/temporalio-1.25.0.tar.gz", hash = "sha256:a3bbec1dcc904f674402cfa4faae480fda490b1c53ea5440c1f1996c562016fb", size = 2152534, upload-time = "2026-04-08T18:53:55.388Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/e3/5676dd10d1164b6d6ca8752314054097b89c5da931e936af402a7b15236c/temporalio-1.25.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:6dc1bc8e1773b1a833d86a7ede2dd90ef4e031ced5b748b59e7f09a5bf9b327d", size = 13943906, upload-time = "2026-04-08T18:53:30.022Z" },
+    { url = "https://files.pythonhosted.org/packages/89/50/7cbf7f845973be986ec165348f72f7a409750842a04d554965a39be5cb4f/temporalio-1.25.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:3c8fdcf79ea5ae8ae2cf6f48072e4a86c3e0f4778f6a8a066c6ff1d336587db4", size = 13298719, upload-time = "2026-04-08T18:53:35.95Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/31/d474bab8535552add6ed289911bf1ffae5d7071823ece1069842190fcaed/temporalio-1.25.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:141f37aaafd7d090ba5c8776e4e9bc60df1fbc64b9f50c8f00e905a436588ddc", size = 13555435, upload-time = "2026-04-08T18:53:41.36Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/c8/e7dc053d6107bf2a037a3c9fe7b86639a25dcb888bde0e1ca366901ee47f/temporalio-1.25.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff7ca5bb80264976477d4dc7a839b3d22af8577ae92306526a061481db49bf92", size = 14052050, upload-time = "2026-04-08T18:53:46.44Z" },
+    { url = "https://files.pythonhosted.org/packages/08/70/9340ed3a578321cbc153041d34834bb1ec3f1f3e3d9cded47cd1b7c3e403/temporalio-1.25.0-cp310-abi3-win_amd64.whl", hash = "sha256:9411534279a2e64847231b6059c214bff4d57cfd1532bd09f333d0b1603daa7f", size = 14299684, upload-time = "2026-04-08T18:53:52.482Z" },
+]
+
+[[package]]
+name = "tenacity"
+version = "9.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
+]
+
+[[package]]
+name = "tiktoken"
+version = "0.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "regex" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", hash = "sha256:b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931", size = 37806, upload-time = "2025-10-06T20:22:45.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/85/be65d39d6b647c79800fd9d29241d081d4eeb06271f383bb87200d74cf76/tiktoken-0.12.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b97f74aca0d78a1ff21b8cd9e9925714c15a9236d6ceacf5c7327c117e6e21e8", size = 1050728, upload-time = "2025-10-06T20:21:52.756Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/42/6573e9129bc55c9bf7300b3a35bef2c6b9117018acca0dc760ac2d93dffe/tiktoken-0.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2b90f5ad190a4bb7c3eb30c5fa32e1e182ca1ca79f05e49b448438c3e225a49b", size = 994049, upload-time = "2025-10-06T20:21:53.782Z" },
+    { url = "https://files.pythonhosted.org/packages/66/c5/ed88504d2f4a5fd6856990b230b56d85a777feab84e6129af0822f5d0f70/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:65b26c7a780e2139e73acc193e5c63ac754021f160df919add909c1492c0fb37", size = 1129008, upload-time = "2025-10-06T20:21:54.832Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad", size = 1152665, upload-time = "2025-10-06T20:21:56.129Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/fe/26df24ce53ffde419a42f5f53d755b995c9318908288c17ec3f3448313a3/tiktoken-0.12.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:35a2f8ddd3824608b3d650a000c1ef71f730d0c56486845705a8248da00f9fe5", size = 1194230, upload-time = "2025-10-06T20:21:57.546Z" },
+    { url = "https://files.pythonhosted.org/packages/20/cc/b064cae1a0e9fac84b0d2c46b89f4e57051a5f41324e385d10225a984c24/tiktoken-0.12.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:83d16643edb7fa2c99eff2ab7733508aae1eebb03d5dfc46f5565862810f24e3", size = 1254688, upload-time = "2025-10-06T20:21:58.619Z" },
+    { url = "https://files.pythonhosted.org/packages/81/10/b8523105c590c5b8349f2587e2fdfe51a69544bd5a76295fc20f2374f470/tiktoken-0.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffc5288f34a8bc02e1ea7047b8d041104791d2ddbf42d1e5fa07822cbffe16bd", size = 878694, upload-time = "2025-10-06T20:21:59.876Z" },
+    { url = "https://files.pythonhosted.org/packages/00/61/441588ee21e6b5cdf59d6870f86beb9789e532ee9718c251b391b70c68d6/tiktoken-0.12.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:775c2c55de2310cc1bc9a3ad8826761cbdc87770e586fd7b6da7d4589e13dab3", size = 1050802, upload-time = "2025-10-06T20:22:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/05/dcf94486d5c5c8d34496abe271ac76c5b785507c8eae71b3708f1ad9b45a/tiktoken-0.12.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a01b12f69052fbe4b080a2cfb867c4de12c704b56178edf1d1d7b273561db160", size = 993995, upload-time = "2025-10-06T20:22:02.788Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/70/5163fe5359b943f8db9946b62f19be2305de8c3d78a16f629d4165e2f40e/tiktoken-0.12.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:01d99484dc93b129cd0964f9d34eee953f2737301f18b3c7257bf368d7615baa", size = 1128948, upload-time = "2025-10-06T20:22:03.814Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/da/c028aa0babf77315e1cef357d4d768800c5f8a6de04d0eac0f377cb619fa/tiktoken-0.12.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:4a1a4fcd021f022bfc81904a911d3df0f6543b9e7627b51411da75ff2fe7a1be", size = 1151986, upload-time = "2025-10-06T20:22:05.173Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/5a/886b108b766aa53e295f7216b509be95eb7d60b166049ce2c58416b25f2a/tiktoken-0.12.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:981a81e39812d57031efdc9ec59fa32b2a5a5524d20d4776574c4b4bd2e9014a", size = 1194222, upload-time = "2025-10-06T20:22:06.265Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f8/4db272048397636ac7a078d22773dd2795b1becee7bc4922fe6207288d57/tiktoken-0.12.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9baf52f84a3f42eef3ff4e754a0db79a13a27921b457ca9832cf944c6be4f8f3", size = 1255097, upload-time = "2025-10-06T20:22:07.403Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/32/45d02e2e0ea2be3a9ed22afc47d93741247e75018aac967b713b2941f8ea/tiktoken-0.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:b8a0cd0c789a61f31bf44851defbd609e8dd1e2c8589c614cc1060940ef1f697", size = 879117, upload-time = "2025-10-06T20:22:08.418Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/76/994fc868f88e016e6d05b0da5ac24582a14c47893f4474c3e9744283f1d5/tiktoken-0.12.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d5f89ea5680066b68bcb797ae85219c72916c922ef0fcdd3480c7d2315ffff16", size = 1050309, upload-time = "2025-10-06T20:22:10.939Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/b8/57ef1456504c43a849821920d582a738a461b76a047f352f18c0b26c6516/tiktoken-0.12.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b4e7ed1c6a7a8a60a3230965bdedba8cc58f68926b835e519341413370e0399a", size = 993712, upload-time = "2025-10-06T20:22:12.115Z" },
+    { url = "https://files.pythonhosted.org/packages/72/90/13da56f664286ffbae9dbcfadcc625439142675845baa62715e49b87b68b/tiktoken-0.12.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:fc530a28591a2d74bce821d10b418b26a094bf33839e69042a6e86ddb7a7fb27", size = 1128725, upload-time = "2025-10-06T20:22:13.541Z" },
+    { url = "https://files.pythonhosted.org/packages/05/df/4f80030d44682235bdaecd7346c90f67ae87ec8f3df4a3442cb53834f7e4/tiktoken-0.12.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:06a9f4f49884139013b138920a4c393aa6556b2f8f536345f11819389c703ebb", size = 1151875, upload-time = "2025-10-06T20:22:14.559Z" },
+    { url = "https://files.pythonhosted.org/packages/22/1f/ae535223a8c4ef4c0c1192e3f9b82da660be9eb66b9279e95c99288e9dab/tiktoken-0.12.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:04f0e6a985d95913cabc96a741c5ffec525a2c72e9df086ff17ebe35985c800e", size = 1194451, upload-time = "2025-10-06T20:22:15.545Z" },
+    { url = "https://files.pythonhosted.org/packages/78/a7/f8ead382fce0243cb625c4f266e66c27f65ae65ee9e77f59ea1653b6d730/tiktoken-0.12.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0ee8f9ae00c41770b5f9b0bb1235474768884ae157de3beb5439ca0fd70f3e25", size = 1253794, upload-time = "2025-10-06T20:22:16.624Z" },
+    { url = "https://files.pythonhosted.org/packages/93/e0/6cc82a562bc6365785a3ff0af27a2a092d57c47d7a81d9e2295d8c36f011/tiktoken-0.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dc2dd125a62cb2b3d858484d6c614d136b5b848976794edfb63688d539b8b93f", size = 878777, upload-time = "2025-10-06T20:22:18.036Z" },
+    { url = "https://files.pythonhosted.org/packages/72/05/3abc1db5d2c9aadc4d2c76fa5640134e475e58d9fbb82b5c535dc0de9b01/tiktoken-0.12.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a90388128df3b3abeb2bfd1895b0681412a8d7dc644142519e6f0a97c2111646", size = 1050188, upload-time = "2025-10-06T20:22:19.563Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/7b/50c2f060412202d6c95f32b20755c7a6273543b125c0985d6fa9465105af/tiktoken-0.12.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:da900aa0ad52247d8794e307d6446bd3cdea8e192769b56276695d34d2c9aa88", size = 993978, upload-time = "2025-10-06T20:22:20.702Z" },
+    { url = "https://files.pythonhosted.org/packages/14/27/bf795595a2b897e271771cd31cb847d479073497344c637966bdf2853da1/tiktoken-0.12.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:285ba9d73ea0d6171e7f9407039a290ca77efcdb026be7769dccc01d2c8d7fff", size = 1129271, upload-time = "2025-10-06T20:22:22.06Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/de/9341a6d7a8f1b448573bbf3425fa57669ac58258a667eb48a25dfe916d70/tiktoken-0.12.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:d186a5c60c6a0213f04a7a802264083dea1bbde92a2d4c7069e1a56630aef830", size = 1151216, upload-time = "2025-10-06T20:22:23.085Z" },
+    { url = "https://files.pythonhosted.org/packages/75/0d/881866647b8d1be4d67cb24e50d0c26f9f807f994aa1510cb9ba2fe5f612/tiktoken-0.12.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:604831189bd05480f2b885ecd2d1986dc7686f609de48208ebbbddeea071fc0b", size = 1194860, upload-time = "2025-10-06T20:22:24.602Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/1e/b651ec3059474dab649b8d5b69f5c65cd8fcd8918568c1935bd4136c9392/tiktoken-0.12.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8f317e8530bb3a222547b85a58583238c8f74fd7a7408305f9f63246d1a0958b", size = 1254567, upload-time = "2025-10-06T20:22:25.671Z" },
+    { url = "https://files.pythonhosted.org/packages/80/57/ce64fd16ac390fafde001268c364d559447ba09b509181b2808622420eec/tiktoken-0.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:399c3dd672a6406719d84442299a490420b458c44d3ae65516302a99675888f3", size = 921067, upload-time = "2025-10-06T20:22:26.753Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/a4/72eed53e8976a099539cdd5eb36f241987212c29629d0a52c305173e0a68/tiktoken-0.12.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2c714c72bc00a38ca969dae79e8266ddec999c7ceccd603cc4f0d04ccd76365", size = 1050473, upload-time = "2025-10-06T20:22:27.775Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/d7/0110b8f54c008466b19672c615f2168896b83706a6611ba6e47313dbc6e9/tiktoken-0.12.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cbb9a3ba275165a2cb0f9a83f5d7025afe6b9d0ab01a22b50f0e74fee2ad253e", size = 993855, upload-time = "2025-10-06T20:22:28.799Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/77/4f268c41a3957c418b084dd576ea2fad2e95da0d8e1ab705372892c2ca22/tiktoken-0.12.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:dfdfaa5ffff8993a3af94d1125870b1d27aed7cb97aa7eb8c1cefdbc87dbee63", size = 1129022, upload-time = "2025-10-06T20:22:29.981Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/2b/fc46c90fe5028bd094cd6ee25a7db321cb91d45dc87531e2bdbb26b4867a/tiktoken-0.12.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:584c3ad3d0c74f5269906eb8a659c8bfc6144a52895d9261cdaf90a0ae5f4de0", size = 1150736, upload-time = "2025-10-06T20:22:30.996Z" },
+    { url = "https://files.pythonhosted.org/packages/28/c0/3c7a39ff68022ddfd7d93f3337ad90389a342f761c4d71de99a3ccc57857/tiktoken-0.12.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:54c891b416a0e36b8e2045b12b33dd66fb34a4fe7965565f1b482da50da3e86a", size = 1194908, upload-time = "2025-10-06T20:22:32.073Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/0d/c1ad6f4016a3968c048545f5d9b8ffebf577774b2ede3e2e352553b685fe/tiktoken-0.12.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5edb8743b88d5be814b1a8a8854494719080c28faaa1ccbef02e87354fe71ef0", size = 1253706, upload-time = "2025-10-06T20:22:33.385Z" },
+    { url = "https://files.pythonhosted.org/packages/af/df/c7891ef9d2712ad774777271d39fdef63941ffba0a9d59b7ad1fd2765e57/tiktoken-0.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f61c0aea5565ac82e2ec50a05e02a6c44734e91b51c10510b084ea1b8e633a71", size = 920667, upload-time = "2025-10-06T20:22:34.444Z" },
+]
+
+[[package]]
+name = "tokenizers"
+version = "0.22.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", hash = "sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917", size = 372115, upload-time = "2026-01-05T10:45:15.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/97/5dbfabf04c7e348e655e907ed27913e03db0923abb5dfdd120d7b25630e1/tokenizers-0.22.2-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c", size = 3100275, upload-time = "2026-01-05T10:41:02.158Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/47/174dca0502ef88b28f1c9e06b73ce33500eedfac7a7692108aec220464e7/tokenizers-0.22.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001", size = 2981472, upload-time = "2026-01-05T10:41:00.276Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/84/7990e799f1309a8b87af6b948f31edaa12a3ed22d11b352eaf4f4b2e5753/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7", size = 3290736, upload-time = "2026-01-05T10:40:32.165Z" },
+    { url = "https://files.pythonhosted.org/packages/78/59/09d0d9ba94dcd5f4f1368d4858d24546b4bdc0231c2354aa31d6199f0399/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd", size = 3168835, upload-time = "2026-01-05T10:40:38.847Z" },
+    { url = "https://files.pythonhosted.org/packages/47/50/b3ebb4243e7160bda8d34b731e54dd8ab8b133e50775872e7a434e524c28/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5", size = 3521673, upload-time = "2026-01-05T10:40:56.614Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/fa/89f4cb9e08df770b57adb96f8cbb7e22695a4cb6c2bd5f0c4f0ebcf33b66/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e", size = 3724818, upload-time = "2026-01-05T10:40:44.507Z" },
+    { url = "https://files.pythonhosted.org/packages/64/04/ca2363f0bfbe3b3d36e95bf67e56a4c88c8e3362b658e616d1ac185d47f2/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b", size = 3379195, upload-time = "2026-01-05T10:40:51.139Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67", size = 3274982, upload-time = "2026-01-05T10:40:58.331Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/28/5f9f5a4cc211b69e89420980e483831bcc29dade307955cc9dc858a40f01/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4", size = 9478245, upload-time = "2026-01-05T10:41:04.053Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/fb/66e2da4704d6aadebf8cb39f1d6d1957df667ab24cff2326b77cda0dcb85/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a", size = 9560069, upload-time = "2026-01-05T10:45:10.673Z" },
+    { url = "https://files.pythonhosted.org/packages/16/04/fed398b05caa87ce9b1a1bb5166645e38196081b225059a6edaff6440fac/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a", size = 9899263, upload-time = "2026-01-05T10:45:12.559Z" },
+    { url = "https://files.pythonhosted.org/packages/05/a1/d62dfe7376beaaf1394917e0f8e93ee5f67fea8fcf4107501db35996586b/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5", size = 10033429, upload-time = "2026-01-05T10:45:14.333Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/18/a545c4ea42af3df6effd7d13d250ba77a0a86fb20393143bbb9a92e434d4/tokenizers-0.22.2-cp39-abi3-win32.whl", hash = "sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92", size = 2502363, upload-time = "2026-01-05T10:45:20.593Z" },
+    { url = "https://files.pythonhosted.org/packages/65/71/0670843133a43d43070abeb1949abfdef12a86d490bea9cd9e18e37c5ff7/tokenizers-0.22.2-cp39-abi3-win_amd64.whl", hash = "sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48", size = 2747786, upload-time = "2026-01-05T10:45:18.411Z" },
+    { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" },
+]
+
+[[package]]
+name = "typer"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" },
+]
+
+[[package]]
+name = "types-protobuf"
+version = "6.32.1.20260221"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/e2/9aa4a3b2469508bd7b4e2ae11cbedaf419222a09a1b94daffcd5efca4023/types_protobuf-6.32.1.20260221.tar.gz", hash = "sha256:6d5fb060a616bfb076cbb61b4b3c3969f5fc8bec5810f9a2f7e648ee5cbcbf6e", size = 64408, upload-time = "2026-02-21T03:55:13.916Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/e8/1fd38926f9cf031188fbc5a96694203ea6f24b0e34bd64a225ec6f6291ba/types_protobuf-6.32.1.20260221-py3-none-any.whl", hash = "sha256:da7cdd947975964a93c30bfbcc2c6841ee646b318d3816b033adc2c4eb6448e4", size = 77956, upload-time = "2026-02-21T03:55:12.894Z" },
+]
+
+[[package]]
+name = "types-requests"
+version = "2.33.0.20260408"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/6a/749dc53a54a3f35842c1f8197b3ca6b54af6d7458a1bfc75f6629b6da666/types_requests-2.33.0.20260408.tar.gz", hash = "sha256:95b9a86376807a216b2fb412b47617b202091c3ea7c078f47cc358d5528ccb7b", size = 23882, upload-time = "2026-04-08T04:34:49.33Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/b8/78fd6c037de4788c040fdd323b3369804400351b7827473920f6c1d03c10/types_requests-2.33.0.20260408-py3-none-any.whl", hash = "sha256:81f31d5ea4acb39f03be7bc8bed569ba6d5a9c5d97e89f45ac43d819b68ca50f", size = 20739, upload-time = "2026-04-08T04:34:48.325Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uncalled-for"
+version = "0.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/68/35c1d87e608940badbcfeb630347aa0509897284684f61fab6423d02b253/uncalled_for-0.3.1.tar.gz", hash = "sha256:5e412ac6708f04b56bef5867b5dcf6690ebce4eb7316058d9c50787492bb4bca", size = 49693, upload-time = "2026-04-07T13:05:06.462Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/e1/7ec67882ad8fc9f86384bef6421fa252c9cbe5744f8df6ce77afc9eca1f5/uncalled_for-0.3.1-py3-none-any.whl", hash = "sha256:074cdc92da8356278f93d0ded6f2a66dd883dbecaf9bc89437646ee2289cc200", size = 11361, upload-time = "2026-04-07T13:05:05.341Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.44.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/da/6eee1ff8b6cbeed47eeb5229749168e81eb4b7b999a1a15a7176e51410c9/uvicorn-0.44.0.tar.gz", hash = "sha256:6c942071b68f07e178264b9152f1f16dfac5da85880c4ce06366a96d70d4f31e", size = 86947, upload-time = "2026-04-06T09:23:22.826Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/23/a5bbd9600dd607411fa644c06ff4951bec3a4d82c4b852374024359c19c0/uvicorn-0.44.0-py3-none-any.whl", hash = "sha256:ce937c99a2cc70279556967274414c087888e8cec9f9c94644dfca11bd3ced89", size = 69425, upload-time = "2026-04-06T09:23:21.524Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" },
+    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" },
+    { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" },
+    { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" },
+    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" },
+    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" },
+    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" },
+    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" },
+    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" },
+    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" },
+    { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" },
+    { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" },
+    { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" },
+    { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" },
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" },
+    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" },
+    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" },
+    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
+[[package]]
+name = "xai-sdk"
+version = "1.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "googleapis-common-protos" },
+    { name = "grpcio" },
+    { name = "opentelemetry-sdk" },
+    { name = "packaging" },
+    { name = "protobuf" },
+    { name = "pydantic" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/32/bb8385f7a3b05ce406b689aa000c9a34289caa1526f1c093a1cefc0d9695/xai_sdk-1.11.0.tar.gz", hash = "sha256:ca87a830d310fb8e06fba44fb2a8c5cdf0d9f716b61126eddd51b7f416a63932", size = 404313, upload-time = "2026-03-27T18:23:10.091Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/76/86d9a3589c725ce825d2ed3e7cb3ecf7f956d3fd015353d52197bb341bcd/xai_sdk-1.11.0-py3-none-any.whl", hash = "sha256:fe58ce6d8f8115ae8bd57ded57bcd847d0bb7cb28bb7b236abefd4626df1ed8d", size = 251388, upload-time = "2026-03-27T18:23:08.573Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.23.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
+    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
+    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
+    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
+    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
+    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
+    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
+    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
+    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
+    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
+    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
+    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
+    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
+    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
+    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
+    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
+    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
+    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
+    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
+    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
+    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
+    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
+    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
+    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
+    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
+    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
+    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
+    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
+    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
+    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
+    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]